Retrieves the {@link HortonMachine}. If it exists, that instance is returned.

@return the horton machine annotations class.
327991
public synchronized static HortonMachine getInstance() {
        if (hortonMachine == null) {
            hortonMachine = new HortonMachine(null);
            hortonMachine.gatherInformations();
        }
        return hortonMachine;
    }
1011380
@Override
    public ClassLoader getClassLoader(String identifier) throws IllegalArgumentException {
        if (identifier == null)
            return null;
        ThreadContextClassLoader classloader = tcclStore.retrieve(identifier);
        if (classloader != null) {
            return classloader;
        }
        return null;
    }
627021
@SuppressWarnings("unchecked")
    public <A extends Annotation> FieldProcessor<A> getProcessor(final Class<A> annoClass) {
        ArgUtils.notNull(annoClass, "annoClass");
        
        return (FieldProcessor<A>) pocessorMap.get(annoClass);
    }
1286413
public String getMachineIdString() throws NoSuchAlgorithmException,
        SocketException, UnknownHostException {
        return calculator.getMachineIdString(useNetwork, useHostName, useArchitecture);
    }
1231569
public ClassDoc superclass() {
        if (isInterface() || isAnnotationType()) return null;
        if (tsym == env.syms.objectType.tsym) return null;
        ClassSymbol c = (ClassSymbol)env.types.supertype(type).tsym;
        if (c == null || c == tsym) c = (ClassSymbol)env.syms.objectType.tsym;
        return env.getClassDoc(c);
    }
932162
<T> DynamoDBTable getTable(Class<T> clazz) {
        DynamoDBTable table = clazz.getAnnotation(DynamoDBTable.class);
        if ( table == null )
            throw new DynamoDBMappingException("Class " + clazz + " must be annotated with " + DynamoDBTable.class);
        return table;
    }
351806
public static final TermFactory getTermFactory() {
		if (tf == null) {
			try {
				@SuppressWarnings("unchecked")
				Class<? extends TermFactory> clazz = (Class<? extends TermFactory>) Class
						.forName(DEFAULT_TERM_FACTORY);
				Method m = clazz.getMethod("getInstance");
				registerTermFactory((TermFactory) m.invoke(null));
				log.debug("Retrived {} as default TermFactory implementation.",
						DEFAULT_TERM_FACTORY);
			} catch (Exception e) {
				log.error("Unable to get TermFactory from default", e);
				throw new RuntimeException(
						"No TermFactory implementation registered!");
			}
		}
		return tf;
	}
295704
protected final Class<T> getEntityClass() {

		@SuppressWarnings("unchecked")
		final Class<T> result = (Class<T>) TypeHelper.getTypeArguments(JpaSearchRepository.class, this.getClass()).get(0);
		return result;
	}
308074
@SuppressWarnings("rawtypes")
    public Set<Class> getManagedClasses() {
        Set<Class> managedClasses = new HashSet<Class>();
        Collection<AbstractBlueprintBeanDefinitionParser> abstractBlueprintBeanDefinitionParsers =
            namespaceRegistrations.values();
        for (AbstractBlueprintBeanDefinitionParser abstractBlueprintBeanDefinitionParser : abstractBlueprintBeanDefinitionParsers) {
            managedClasses.add(abstractBlueprintBeanDefinitionParser.getRuntimeClass());
        }
        return managedClasses;
    }
301386
public static TrmMessageFactory getInstance()  {
	  if (_instance == null) {
		  synchronized(TrmMessageFactory.class) {
			  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createFactoryInstance");
			    try {
			      Class cls = Class.forName(TRM_MESSAGE_FACTORY_CLASS);
			      _instance = (TrmMessageFactory) cls.newInstance();
			    }
			    catch (Exception e) {
			      FFDCFilter.processException(e, "com.ibm.ws.sib.mfp.TrmMessageFactory.createFactoryInstance", "112");
			      SibTr.error(tc,"UNABLE_TO_CREATE_TRMFACTORY_CWSIF0021",e);
			    }
			    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createFactoryInstance",_instance);
			  }
		   }

	  return _instance;
  }
762076
public String getHiveExecutionEngine() {
        String executionEngine = hiveConfSystemOverride.get(HiveConf.ConfVars.HIVE_EXECUTION_ENGINE.varname);
        return executionEngine == null ? HiveConf.ConfVars.HIVE_EXECUTION_ENGINE.getDefaultValue() : executionEngine;
    }
1333091
public Class getJavaClass()
  {
    try {
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
      
      return Class.forName(getName(), false, loader);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
577459
protected <T> ManagedObjectFactory<T> getEJBManagedObjectFactory(BeanMetaData bmd, Class<T> klass) throws EJBConfigurationException {
        ManagedObjectFactory<T> factory = null;
        ManagedObjectService managedObjectService = getManagedObjectService();
        if (managedObjectService != null) {
            try {
                factory = managedObjectService.createEJBManagedObjectFactory(bmd._moduleMetaData, klass, bmd.j2eeName.getComponent());
                //TODO the isManaged method could be moved to the ManagedObjectService and then wouldn't need to create the factory
                if (!factory.isManaged()) {
                    factory = null;
                }
            } catch (ManagedObjectException e) {
                throw new EJBConfigurationException(e);
            }
        }

        return factory;
    }
1180848
protected CodeGenerator getGenerator()
    {
        if (_generator == null)
        {
            //
            // Locate the class that wraps the Velocity code generation process
            //
            AnnotationProcessorEnvironment env = getAnnotationProcessorEnvironment();

            try 
            {
                _generator = new VelocityGenerator(env);
            }
            catch (Exception e)
            {
                throw new CodeGenerationException("Unable to create code generator", e); 
            }
        }
        return _generator;
    }
441985
static JClassLoader getSystemClassLoader()
  {
    if (_staticClassLoader == null)
      _staticClassLoader = JClassLoaderWrapper.create(ClassLoader.getSystemClassLoader());

    return _staticClassLoader;
  }
986818
public BshClassManager getClassManager() {
        if (this.classManager != null)
            return this.classManager;
        if (this.parent != null && this.parent != JAVACODE)
            return this.parent.getClassManager();
        this.setClassManager(BshClassManager
                .createClassManager(null/* interp */));
        // Interpreter.debug("No class manager namespace:" +this);
        return this.classManager;
    }
970296
public static DDFManager get(EngineType engineType) throws DDFException {
    if (engineType == null) {
      engineType = EngineType.fromString(ConfigConstant.ENGINE_NAME_DEFAULT.toString());
    }

    String className = Config.getValue(engineType.name(), ConfigConstant.FIELD_DDF_MANAGER);
    if (Strings.isNullOrEmpty(className)) {
      throw new DDFException("ERROR: When initializaing ddfmanager, class " +
              className + " not found");
    }

    try {
      DDFManager manager = (DDFManager) Class.forName(className).newInstance();
      if (manager == null) {
        throw new DDFException("ERROR: Initializaing manager fail.");
      }
      return manager;

    } catch (Exception e) {
      // throw new DDFException("Cannot get DDFManager for engine " + engineName, e);
      throw new DDFException(
          "Cannot get DDFManager for engine " + engineType.name() + " " +
                  "classname " + className + " " + e.getMessage());

    }
  }