Get TwoFactorAuthenticatorInterface class

@return Gems\User\TwoFactor\TwoFactorAuthenticatorInterface
164271
public function getTwoFactorAuthenticator($className)
    {
        $object = $this->_loadClass('TwoFactor_' . $className, true);

        if (! $object instanceof TwoFactorAuthenticatorInterface) {
            throw new \Gems_Exception_Coding(sprintf(
                    'The authenticator class %s should be an instance of TwoFactorAuthenticatorInterface.',
                    $className
                    ));
        }

        return $object;
    }
149695
protected function getAuthUser() {
    $principalFactory = ObjectFactory::getInstance('principalFactory');
    $session = ObjectFactory::getInstance('session');
    return $principalFactory->getUser($session->getAuthUser());
  }
505627
public function getAuthenticationEndpoint() {
        switch ( $this->authMode ) {
            case 'OnlineFederation':
                return $this->crmRegion;
            case 'Federation':
                return $this->organizationUrl;
            default:
                throw new \InvalidArgumentException( 'Unsupported authentication mode: ' . $this->authMode );
        }
    }
324757
public function getAdapter()
    {
        if ($this->repositoryAdapter instanceof AdapterInterface) {
            return $this->repositoryAdapter;
        }

        foreach ($this->adapters as $adapterClass) {
            if (class_exists($adapterClass) === false || in_array('Accompli\Chrono\Adapter\AdapterInterface', class_implements($adapterClass)) === false) {
                continue;
            }

            $adapter = new $adapterClass($this->repositoryUrl, $this->repositoryDirectory, $this->processExecutor);
            if ($adapter->supportsRepository()) {
                return $adapter;
            }
        }
    }
1250728
public function getIdentifier()
    {
        if (is_array($this->callback)) {
            $class = $this->callback[0];

            if (is_object($class)) {
                $class = get_class($class);
            }

            return $class . '::' . $this->callback[1];
        }
        else if (is_object($this->callback)) {
            return spl_object_hash((object) $this->callback);
        }

        return (string) $this->callback;
    }
162606
public function getConnectionDescriptor() {
        $reflectionClass = new \ReflectionClass($this->getConnection());
        $reflectionProperty = $reflectionClass->getProperty('_descriptor');
        $reflectionProperty->setAccessible(true);
        return $reflectionProperty->getValue($this->getConnection());
    }
1050464
public function findAuthenticatedUser()
    {

        $token = $this->getSecurityTokenStorage()->getToken();

        if (null !== $token) {

            $user = $token->getUser();

            if (is_object($user) && $user instanceof UserInterface) {
                return $user;
            }

        }
        return null;
    }
1056768
private function getDescriptor()
    {
        if (!is_object($this->descriptor)) {
            $descriptorClass = '\\ntentan\\atiaa\\descriptors\\'.ucfirst($this->config['driver']).'Descriptor';
            $this->descriptor = new $descriptorClass($this);
        }

        return $this->descriptor;
    }
23770
public function ConditionalFactor()
    {
        $not = false;

        if ($this->lexer->isNextToken(Lexer::T_NOT)) {
            $this->match(Lexer::T_NOT);

            $not = true;
        }

        $conditionalPrimary = $this->ConditionalPrimary();

        // Phase 1 AST optimization: Prevent AST\ConditionalFactor
        // if only one AST\ConditionalPrimary is defined
        if (! $not) {
            return $conditionalPrimary;
        }

        $conditionalFactor      = new AST\ConditionalFactor($conditionalPrimary);
        $conditionalFactor->not = $not;

        return $conditionalFactor;
    }
2179
public function classIdentifier()
    {
        if ( $this->ClassIdentifier === null )
        {
            $object = $this->object();
            $this->ClassIdentifier = $object->contentClassIdentifier();
        }

        return $this->ClassIdentifier;
    }
1120353
private function _getUser()
    {
    	// This is likely a duplicate check that could be removed....
        if ( empty($this->_user) ) {
            phpCAS::error(
                'this method should be used only after '.__CLASS__
                .'::forceAuthentication() or '.__CLASS__.'::isAuthenticated()'
            );
        }
        return $this->_user;
    }
226013
protected function getSigner()
    {
        $signerClass = sprintf('Namshi\\JOSE\\Signer\\%s\\%s', $this->encryptionEngine, $this->header['alg']);

        if (class_exists($signerClass)) {
            return new $signerClass();
        }

        throw new InvalidArgumentException(
            sprintf("The algorithm '%s' is not supported for %s", $this->header['alg'], $this->encryptionEngine));
    }
85541
public function getIdentity()
	{
		$identity = parent::getIdentity();

		// if we have our fake identity, we now want to
		// convert it back into the real entity
		// returning reference provides potentially lazy behavior
		if ($identity instanceof FakeIdentity) {
			return $this->entityManager->getReference($identity->getClass(), $identity->getId());
		}

		return $identity;
	}
82370
public function getAuthUser()
    {
        $user = null;
        if ($this->api_auth()->check()) {
            $user = $this->api_auth()->user();
        } else if (\Auth::check()) {
            $user = \Auth::user();
        }
        return $user;
    }
569052
function getAuthAdapter()
    {
        if (!$this->authAdapter)
            $this->setAuthAdapter(new DigestFileAuthAdapter);

        // always use current identity
        $this->authAdapter->setIdentity($this->identity());

        return $this->authAdapter;
    }
232736
public function getDeclaringClass()
    {
        if (is_array($this->routineName) === false) {
            return null;
        }
        
        $refClass     = parent::getDeclaringClass();
        $moufRefClass = new MoufReflectionClass($refClass->getName());
        return $moufRefClass;
    }
1371584
public function getCacheFrontendFactory() {
		if ($this->_cacheFrontendFactory === null) {
			if ($this instanceof LocatorAwareInterface && $this->hasLocator()) {
				$locator   = $this->getLocator();
				$serviceId = $this->getCacheFrontendFactoryServiceId();
				
				if ($locator->has($serviceId)) {
					$this->_cacheFrontendFactory = $locator->get($serviceId);
					return $this->_cacheFrontendFactory;
				}
			}
			
			throw new NoFrontend('Unable to provide the cache frontend\'s factory');
		}
		
		return $this->_cacheFrontendFactory;
	}