Returns the {@link ClassLocator} instance to use.

@return		the instance
433335
protected ClassLocator getClassLocator() {
    ClassLocator  	result;

    result = ClassLocator.getSingleton(m_ClassTraversal);
    if (result.isOnlyDefaultConstructor() != isOnlyDefaultConstructor())
      result.setOnlyDefaultConstructor(isOnlyDefaultConstructor());
    if (result.isOnlySerializable() != isOnlySerializable())
      result.setOnlySerializable(isOnlySerializable());

    return result;
  }
430914
public static GoogleConnector getInstance() {
        if (instance == null) {
            try {
                instance = new GoogleConnector();
            } catch (Exception e) {
                throw new RuntimeException("The GoogleConnector could not be instanced!", e);
            }
        }
        return instance;
    }
1221420
@Pure
	public static Iterator<URL> getClasspath() {
		Iterator<URL> iterator = getStartClasspath();

		final ClassLoader loader = ClassLoaderFinder.findClassLoader();
		try {
			final DynamicURLClassLoader dLoader = (DynamicURLClassLoader) loader;
			iterator = new FilteringIterator(Arrays.asList(dLoader.getURLs()).iterator());
		} catch (ClassCastException exception1) {
			if (ClasspathUtil.class.getClassLoader() != loader) {
				try {
					try (URLClassLoader dLoader = (URLClassLoader) loader) {
						iterator = new IteratorIterator(
								new FilteringIterator(Arrays.asList(dLoader.getURLs()).iterator()),
								iterator);
					}
				} catch (ClassCastException | IOException exception2) {
					//
				}
			}
		}

		return iterator;
	}
1091635
public static ImageLoader getInstance() {
		if (instance == null) {
			synchronized (ImageLoader.class) {
				if (instance == null) {
					instance = new ImageLoader();
				}
			}
		}
		return instance;
	}
939454
@Override
	@Pure
	public GeoLocation getGeoLocation() {
		final Rectangle2d b = getBoundingBox();
		if (b == null) {
			return new GeoLocationNowhere(getUUID());
		}
		return new GeoLocationPoint(b.getCenterX(), b.getCenterY());
	}
112781
private static ClassLoader findClassLoader() throws ConfigurationError {
        // Figure out which ClassLoader to use for loading the provider
        // class.  If there is a Context ClassLoader then use it.

        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

        if (debug) debugPrintln(
            "Using context class loader: "
            + classLoader);

        if (classLoader == null) {
            // if we have no Context ClassLoader
            // so use the current ClassLoader
            classLoader = FactoryFinder.class.getClassLoader();
            if (debug) debugPrintln(
                "Using the class loader of FactoryFinder: "
                + classLoader);
        }

        return classLoader;
    }
82827
public static Class<?> getCallingClass() {
        ClassContextSecurityManager securityManager = getSecurityManager();
        if (securityManager == null)
            return null;
        Class<?>[] trace = securityManager.getClassContext();
        String thisClassName = Util.class.getName();

        // Advance until Util is found
        int i;
        for (i = 0; i < trace.length; i++) {
            if (thisClassName.equals(trace[i].getName()))
                break;
        }

        // trace[i] = Util; trace[i+1] = caller; trace[i+2] = caller's caller
        if (i >= trace.length || i + 2 >= trace.length) {
            throw new IllegalStateException("Failed to find org.slf4j.helpers.Util or its caller in the stack; " + "this should not happen");
        }

        return trace[i + 2];
    }
1154991
public static ClassLoader getClassLoader() {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        return (classLoader != null) ? classLoader : ClassLoaderUtils.class.getClassLoader();
    }
619713
public static MockClassLoader getInstance() {

        if (MockClassLoader.instance == null) {

            MockClassLoader.instance = new MockClassLoader();
        }

        return MockClassLoader.instance;
    }
1208704
private MethodHandle findConstructor() {
    try {
      MethodHandle mh = MethodHandles.publicLookup().findConstructor(clazz,
          MethodType.methodType(void.class, getIdType()));
      return mh;
    } catch (NoSuchMethodException | IllegalAccessException exp) {
      String pattern = "Class %s requires a public constructor with one parameter of type %s";
      String error = String.format(pattern, clazz.getName(), getIdType());
      throw new EntityManagerException(error, exp);
    }
  }
952226
public static ClassLoader getClassLoader(final Class<?> clazz) {
        // Context class loader can be null
        final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        if (contextClassLoader != null) {
            return contextClassLoader;
        }
        if (clazz != null) {
            // The class loader for a specific class can also be null
            final ClassLoader clazzClassLoader = clazz.getClassLoader();
            if (clazzClassLoader != null) {
                return clazzClassLoader;
            }
        }
        // The only class loader we can rely on for not being null is the system
        // one
        return ClassLoader.getSystemClassLoader();
    }
901817
public ClassLoader getClassLoader() throws UnableToAdaptException, MalformedURLException {
        lock.readLock().lock();
        try {
            if (classloader != null)
                return classloader;
        } finally {
            lock.readLock().unlock();
        }
        if (!rarFileExists())
            return null;
        lock.writeLock().lock();
        try {
            if (classloader == null) {
                classloader = createRarClassLoader();
            }
            return classloader;
        } finally {
            lock.writeLock().unlock();
        }
    }
1232634
public SAXSourceLocator getLocator()
  {

    if (m_stylesheetLocatorStack.isEmpty())
    {
      SAXSourceLocator locator = new SAXSourceLocator();

      locator.setSystemId(this.getStylesheetProcessor().getDOMsystemID());

      return locator;

      // m_stylesheetLocatorStack.push(locator);
    }

    return ((SAXSourceLocator) m_stylesheetLocatorStack.peek());
  }
445265
public static String findSingleMainClass(JarFile jarFile, String classesLocation)
            throws IOException {
        MainClassesCallback callback = new MainClassesCallback();
        MainClassFinder.doWithMainClasses(jarFile, classesLocation, callback);
        return callback.getMainClass();
    }
463705
private static Constructor getConstructor()
  {
    if (_tc.isEntryEnabled()) SibTr.entry(_tc, "getConstructor");
    
    if (_constructor == null)
    {
      try
      {
        Class clazz = Class.forName("com.ibm.ws.sib.exitpoint.systemcontext.SystemContextImpl");
        _constructor = clazz.getConstructor(new Class[] {JsApiMessage.class});
      }
      catch (Exception e)
      {
        com.ibm.ws.ffdc.FFDCFilter.processException(e, "com.ibm.ws.sib.exitpoint.systemcontext.SystemContextFactory.getConstructor", "66");
        
        NoSuchMethodError newE = new NoSuchMethodError();
        newE.initCause(e);
        
        if (_tc.isEntryEnabled()) SibTr.exit(_tc, "getConstructor", newE);
        throw newE;
      }
    }
    
    if (_tc.isEntryEnabled()) SibTr.exit(_tc, "getConstructor", _constructor);
    return _constructor;
  }
503627
public DestinationLocationManager getDestinationLocationManager() {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled()) {
            SibTr.entry(tc, "getDestinationLocationManager");
            SibTr.exit(tc, "getDestinationLocationManager",
                       _destinationLocationManager);
        }
        return _destinationLocationManager;
    }
580697
public static PropertiesLoader getPropertiesLoader() {
		synchronized (PropertiesLoader.class) {
			final ClassLoader classLoader = ConfigurableClassLoader.INSTANCE.getClassLoader();
			PropertiesLoader loader = clMap.get(classLoader);
			if (loader == null) {
				try {
					loader = new PropertiesLoader(MASTER_PLUGIN_FILE, EXTRA_PLUGIN_FILE);
					clMap.put(classLoader, loader);
				} catch (final IOException ex) {
					throw new RuntimeException(ex);
				}
			}
			return loader;
		}
	}