obtains a LockStrategy for Object obj. The Strategy to be used is
selected by evaluating the ClassDescriptor of obj.getClass().

@return LockStrategy
425215
public static LockStrategy getStrategyFor(Object obj)
    {
        int isolationLevel = getIsolationLevel(obj);
        switch (isolationLevel)
        {
            case IsolationLevels.IL_READ_UNCOMMITTED:
                return readUncommitedStrategy;
            case IsolationLevels.IL_READ_COMMITTED:
                return readCommitedStrategy;
            case IsolationLevels.IL_REPEATABLE_READ:
                return readRepeatableStrategy;
            case IsolationLevels.IL_SERIALIZABLE:
                return serializableStrategy;
            case IsolationLevels.IL_OPTIMISTIC:
                return noopStrategy;
            case IsolationLevels.IL_NONE:
                return noopStrategy;
            default:
                return readUncommitedStrategy;
        }
    }
422054
public function getObject()
    {
        //security check
        if (!isset($this->_object)) {
            $condition = array($this->_property => $this->_value);
            $repository = AnDomain::getRepository($this->getIdentifier());

            //check if an entity exiting in the repository with $condition
            if ($data = $repository->find($condition, false)) {
                $this->_object = $data;

                return $this->_object;
            }

            //now time to fetch the object from the database
            //but lets grab all the similar entities all together
            $handle = $this->getIdentifier().$this->_property;
            $values = isset(self::$_values[$handle]) ? self::$_values[$handle] : array();

            if (empty($values)) {
                return;
            }

            $values = AnHelperArray::unique($values);
            $query = $repository->getQuery();
            AnDomainQueryHelper::applyFilters($query, $this->_relationship->getQueryFilters());
            $query->where(array($this->_property => $values));
            $entities = $repository->fetchSet($query);

            //the object must have been fetched with the set
            //in the previous line
            //if the object is still not fetched, then the object
            //doesn't exists in the databse
            $this->_object = $repository->find($condition, false);

            if (!$this->_object) {
                //lets cache the null result to prevent re-fetching
                //the same result
                $query = $repository->getQuery()->where($condition)->limit(1);

                if ($repository->hasBehavior('cachable')) {
                    $repository->emptyCache($query);
                }

                $this->_object = false;

                //if it's a required one-to-one relationship
                //then instantaite a new entity if the entity doesn't exists
                if ($this->_relationship->isOneToOne()) {
                    if ($this->_relationship->isRequired()) {
                        $this->_object = $repository->getEntity(array(
                            'data' => array($this->_property => $this->_value),
                        ));
                    }
                }
            }

            unset(self::$_values[$handle]);
        }

        return $this->_object;
    }
425571
public function getObject()
    {
        if ($this->thawedObject === null) {
            $this->thawedObject = $this->storage->fetch($this->id);
        }

        return $this->thawedObject;
    }
319657
function(){
      var func;

      if(typeof waterlock.config.authMethod[0] === 'object'){
        func = this._handleObjects;
      }else if(typeof waterlock.config.authMethod === 'object'){
        func = this._handleObject;
      }else{
        func = this._handleName;
      }

      return func.apply(this, [waterlock.config.authMethod]);
    }
698640
public function getClass()
    {
        return $this->refl->isAbstract()
            ? null
            : new ParsedClass(
                (string) $this->refl->getDocComment(),
                $this->getCleanReflectionName(),
                $this->refl->getNamespaceName(),
                $this->getMethods()
            );
    }
409977
public Class<T> getT() {
        Type subTyping = Types.getBaseClass(getClass(), Descriptor.class);
        if (!(subTyping instanceof ParameterizedType)) {
            throw new IllegalStateException(getClass()+" doesn't extend Descriptor with a type parameter.");
        }
        return Types.erasure(Types.getTypeArgument(subTyping, 0));
    }
574018
public static <T> Class<T> getClass(final T object) {

    if (object == null) {
      return null;
    }
    @SuppressWarnings("unchecked")
    Class<T> clazz = (Class<T>) object.getClass();
    return clazz;
  }
831250
private function getInstance()
    {
        if (is_null($this->instance)) {
            $this->instance = \RegexGuard\Factory::getGuard();
        }
        
        return $this->instance;
    }
1166771
protected function getLockout()
    {
        if (!$this->lockout || !$this->lockout instanceof LockoutStorage) {
            $lockout = $this->getOption(self::OPTION_LOCKOUT_STORAGE);
            $this->lockout = ($lockout and class_exists($lockout)) ? new $lockout : new RdfLockoutStorage();
        }

        return $this->lockout;
    }
1092478
@Override
    public final T get() {
        if (obj == null) {
            synchronized (lock) {
                if (obj == null) {
                    obj = create();
                }
            }
        }
        return obj;
    }
518231
protected function getCloner()
    {
        if (!$this->cloner) {
            $clonerOptions = $this->getClonerOptions();
            if (isset($clonerOptions['casters'])) {
                $this->cloner = new VarCloner($clonerOptions['casters']);
            } else {
                $this->cloner = new VarCloner();
            }
            if (isset($clonerOptions['additional_casters'])) {
                $this->cloner->addCasters($clonerOptions['additional_casters']);
            }
            if (isset($clonerOptions['max_items'])) {
                $this->cloner->setMaxItems($clonerOptions['max_items']);
            }
            if (isset($clonerOptions['max_string'])) {
                $this->cloner->setMaxString($clonerOptions['max_string']);
            }
            // setMinDepth was added to Symfony 3.4:
            if (isset($clonerOptions['min_depth']) && method_exists($this->cloner, 'setMinDepth')) {
                $this->cloner->setMinDepth($clonerOptions['min_depth']);
            }
        }
        return $this->cloner;
    }
318186
public static int getIsolationLevel(Object obj)
    {
        Class c = ProxyHelper.getRealClass(obj);
        int isolationLevel = IsolationLevels.IL_READ_UNCOMMITTED;

        try
        {
            ClassDescriptor cld = TxManagerFactory.instance().getCurrentTransaction().getBroker().getClassDescriptor(c);
            isolationLevel = cld.getIsolationLevel();
        }
        catch (PersistenceBrokerException e)
        {
            LoggerFactory.getDefaultLogger().error("[LockStrategyFactory] Can't detect locking isolation level", e);
        }
        return isolationLevel;
    }
698181
protected function getCollectionFromObjectByReference()
    {
        $object       = $this->getObject();
        $refl         = $this->getClassMetadata()->getReflectionClass();
        $reflProperty = $refl->getProperty($this->getCollectionName());

        $reflProperty->setAccessible(true);

        return $reflProperty->getValue($object);
    }
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];
    }
412
public static function getInstance ()
    {
        // If this class is used for multiple singletons, we need to keep
        // track of multiple singleton objects, one for each class name
        static $instances = array();

        // Get class name to use. Use late static binding here,
        // if method is overriden by derived classes.
        $singletonClassName = static::_getInstanceClassName();

        // If already instantiated, use that
        if (isset($instances[$singletonClassName])) {
            return $instances[$singletonClassName];
        }

        // Otherwise create new instance
        $instances[$singletonClassName] = new $singletonClassName (static::_getInstanceFuseValue());

        return $instances[$singletonClassName];
    }
567316
protected function _getStateObject()
    {
        if (is_null($this->_oStateObject)) {
            $this->_oStateObject = oxNew(\OxidEsales\Eshop\Application\Model\State::class);
        }

        return $this->_oStateObject;
    }
994610
public function getObjectInfo()
	{
		$info	= array(
			'name'		=> $this->getClass(),
			'parent'	=> $this->getParent(),
			'methods'	=> $this->getMethods(),
			'vars'		=> $this->getVars(),
		);
		return $info;
	}