Get the instance of GeSHI used by the helper.
487807
protected function _getGeshi()
    {
        if (!$this->_geshi) {
            $this->_geshi = new GeSHi();
        }
        $this->_configureInstance($this->_geshi);
        return $this->_geshi;
    }
519705
private static KunderaProxy getProxyInstance(Class factory, CglibLazyInitializer instance)
    {
        KunderaProxy proxy;
        try
        {
            Enhancer.registerCallbacks(factory, new Callback[] { instance, null });
            proxy = (KunderaProxy) factory.newInstance();
        }
        catch (IllegalAccessException e)
        {
            throw new LazyInitializationException(e);
        }
        catch (InstantiationException e)
        {
            throw new LazyInitializationException(e);
        }
        finally
        {
            Enhancer.registerCallbacks(factory, null);
        }
        return proxy;
    }
1074677
public Instance getInstance(String src, int j) { 
        return (Instance)((ArrayList)sourceLists.get(src)).get(j); 
    }
380326
def find_converter_instance(klass)
      @find_converter_instance ||= {}
      @find_converter_instance[klass] ||= begin
        converters.find { |converter| converter.instance_of?(klass) } || \
          raise("No Converters found for #{klass}")
      end
    end
1241347
private String getInstanceClass(
		final Tuple resultset,
		final int i,
		final Loadable persister,
		final Serializable id,
		final SharedSessionContractImplementor session)
	throws HibernateException {
		String discriminatorColumnName = persister.getDiscriminatorColumnName();
		if ( discriminatorColumnName == null ) {
			return persister.getEntityName();
		}
		else {
			Object value = resultset.get( discriminatorColumnName );
			return persister.getSubclassForDiscriminatorValue( value );
		}
	}
477947
public static LdapHelper getInstance(String instance) {
        if (!helpers.containsKey(instance)) {
            helpers.put(instance, new LdapHelper(instance));
        }
        LdapHelper helper = helpers.get(instance);
        if (!helper.online) {
            helper.loadProperties();
        }
        return helper;
    }
398825
def instances(cls):
        
        l = [i for i in cls.allinstances() if isinstance(i, cls)]
        return l
1002983
def gep(self, i):
        
        if not isinstance(i.type, IntType):
            raise TypeError(i.type)
        return self.element
461209
def _gorg(cls):
    """"""
    assert isinstance(cls, GenericMeta)
    if hasattr(cls, '_gorg'):
        return cls._gorg
    while cls.__origin__ is not None:
        cls = cls.__origin__
    return cls
654274
def get_listener_instance(self, cls):
        
        with self._lock:
            for listener in self._listeners:
                if isinstance(listener, cls):
                    return listener
683845
public static synchronized RenderEngine getInstance() {
    //availableEngines = null;
    if (null == availableEngines) {
      availableEngines = new HashMap();
    }

    if (!availableEngines.containsKey(DEFAULT)) {
      RenderEngine engine = new BaseRenderEngine();
      availableEngines.put(engine.getName(), engine);
    }

    return (RenderEngine) availableEngines.get(DEFAULT);
  }
276098
public static Transform getInstance(Element e, String initial) {
    Transform t = GQuery.data(e, TRANSFORM);
    if (t == null || initial != null) {
      if (initial == null) {
        initial = GQuery.getSelectorEngine().getDocumentStyleImpl().curCSS(e, transform, false);
      }
      t = new Transform(initial);
      GQuery.data(e, TRANSFORM, t);
    }
    return t;
  }
52360
public Object getInstance(ComponentAdapter componentAdapter) {
		Object componentKey = componentAdapter.getComponentKey();
		Object instance = compKeyInstances.get(componentKey);
		if (instance == null) {
			instance = loadSaveInstance(componentAdapter, componentKey);
		}
		return instance;
	}
651250
def _get_instance(self, **kwargs):
        """"""
        current_app.logger.info("Getting instance")
        current_app.logger.debug("kwargs: {}".format(kwargs))

        current_app.logger.info(
            "Loading instance: {}".format(kwargs['obj_id']))
        rec = self.db_query.get_instance(self.db_collection, kwargs['obj_id'])
        g._resource_instance = rec
        current_app.logger.debug(
            "g._resource_instance: {}".format(g._resource_instance))
        return rec
1030774
def instance(cls, *args, **kwargs):
        
        if cls._instance is None:
            cls._instance = cls(*args, **kwargs)
            loaded = cls._instance.reload()
            logging.getLogger('luigi-interface').info('Loaded %r', loaded)

        return cls._instance
1275654
public static SolrDyscoHandler getInstance(String collection) {
        SolrDyscoHandler INSTANCE = INSTANCES.get(collection);
        if (INSTANCE == null) {
            INSTANCE = new SolrDyscoHandler(collection);
            INSTANCES.put(collection, INSTANCE);
        }
        return INSTANCE;
    }
291882
def helper_exist?(helper)
			Object.const_defined?(helper) && 
			Object.const_get(helper).instance_of?(::Module)
		end