get translatorHelper

@return  Zend\Mvc\I18n\Translator
489253
private function getTranslatorHelper()
    {
        if(null === $this->translatorHelper) {
            $this->translatorHelper = $this->serviceLocator->get('MvcTranslator');
        }
    
        return $this->translatorHelper;
    }
120501
public static function getDefaultTranslator()
    {
        if (null === self::$_defaultTranslator) {
            require_once 'Zend/Registry.php';
            if (Zend_Registry::isRegistered('Zend_Translate')) {
                $translator = Zend_Registry::get('Zend_Translate');
                if ($translator instanceof Zend_Translate_Adapter) {
                    return $translator;
                } elseif ($translator instanceof Zend_Translate) {
                    return $translator->getAdapter();
                }
            }
        }

        return self::$_defaultTranslator;
    }
524967
protected function getLabelHelper()
    {
        if ($this->labelHelper) {
            return $this->labelHelper;
        }

        if (method_exists($this->view, 'plugin')) {
            $this->labelHelper = $this->view->plugin('form_label');
        }

        if (!$this->labelHelper instanceof FormLabel) {
            $this->labelHelper = new FormLabel();
        }

        if ($this->hasTranslator()) {
            $this->labelHelper->setTranslator(
                $this->getTranslator(),
                $this->getTranslatorTextDomain()
            );
        }

        return $this->labelHelper;
    }
742092
protected function getQuestionHelper(): QuestionHelper
    {
        if ($this->questionHelper === null) {
            $this->questionHelper = new QuestionHelper();
            $helperSet = new HelperSet([new FormatterHelper()]);
            $this->questionHelper->setHelperSet($helperSet);
        }
        return $this->questionHelper;
    }
972952
protected function classTranslation() {
        if(! $classTranslation = $this['translationClass'])
            $classTranslation = sprintf('App\\%s%s', ucfirst(str_singular($this->getModel()->getTable())), 'Translations');

        return $classTranslation;
    }
1291399
protected static function getSupported()
    {
        $folders = File::directories(root().'resources/translator');

        foreach ($folders as $folder) {
            $lang = explode(root().'resources/translator/', $folder);

            self::$supported[] = $lang[1];
        }
    }
887050
public function getHelper()
	{
		$config = $this->asConfig();
		if (isset($config))
		{
			$config = ConfigHelper::filterConfig($config, 'PHP');
		}
		else
		{
			// Use a dummy config with a regexp that doesn't match anything
			$config = [
				'attrName' => $this->attrName,
				'regexp'   => '/(?!)/',
				'tagName'  => $this->tagName
			];
		}

		return new Helper($config);
	}
978673
protected function getFlashMessengerHelper()
    {
        if ($this->flashMessengerHelper) {
            return $this->flashMessengerHelper;
        }

        if (method_exists($this->view, 'plugin')) {
            $this->flashMessengerHelper = $this->view->plugin('flashmessenger');
        }

        if (!$this->flashMessengerHelper instanceof FlashMessenger) {
            $this->flashMessengerHelper = new FlashMessenger();
            $this->flashMessengerHelper->setView($this->getView());
        }

        return $this->flashMessengerHelper;
    }
453631
protected function getEscapeHtmlHelper()
    {
        if ($this->escapeHtmlHelper) {
            return $this->escapeHtmlHelper;
        }

        $this->escapeHtmlHelper = $this->view->plugin('escapehtml');

        return $this->escapeHtmlHelper;
    }
886442
protected function getTransformer()
    {
        $transformer = null;

        // Check if controller specifies a resource
        if (! is_null(static::$transformer)) {
            $transformer = static::$transformer;
        }

        // Otherwise, check if model is specified
        else {
            // If it is, check if the controller's model specifies the transformer
            if (! is_null(static::$model)) {
                // If it does, use it
                if (! is_null((static::$model)::$transformer)) {
                    $transformer = (static::$model)::$transformer;
                }
            }
        }

        // This is the default transformer, if one is not specified
        if (is_null($transformer)) {
            $transformer = BaseTransformer::class;
        }

        return new $transformer;
    }
110012
public function getTranslation()
    {
        $attributeValueTranslation = $this->getTranslationByLocale($this->locale);

        if (!$attributeValueTranslation) {
            $attributeValueTranslation = $this->getTranslationByLocale($this->fallbackLocale);
        }

        if (!$attributeValueTranslation) {
            $attributeValueTranslation = new AttributeValueTranslation();
            $attributeValueTranslation->setLocale($this->locale);
            $attributeValueTranslation->setAttributeValue($this->entity);

            $this->entity->addTranslation($attributeValueTranslation);
        }

        return $attributeValueTranslation;
    }
654510
private function getTranslation()
    {
        $operatorTranslation = null;
        foreach ($this->entity->getTranslations() as $translation) {
            if ($translation->getLocale() == $this->locale) {
                $operatorTranslation = $translation;
            }
        }
        if (!$operatorTranslation) {
            $operatorTranslation = new OperatorTranslation();
            $operatorTranslation->setLocale($this->locale);
            $operatorTranslation->setOperator($this->entity);
            $this->entity->addTranslation($operatorTranslation);
        }

        return $operatorTranslation;
    }
364812
protected function getMessengerHelper()
    {
        if ( $this->messengerHelper )
        {
            return $this->messengerHelper;
        }

        if ( method_exists( $this->view, 'plugin' ) )
        {
            $this->messengerHelper = $this->view
                                          ->plugin( 'messenger' );
        }

        if ( ! $this->messengerHelper instanceof Messenger )
        {
            $this->messengerHelper = new Messenger();
        }

        return $this->messengerHelper;
    }
428532
protected function getFormMessagesHelper()
    {
        if ($this->formMessagesHelper) {
            return $this->formMessagesHelper;
        }

        if (method_exists($this->view, 'plugin')) {
            $this->formMessagesHelper = $this->view->plugin($this->defaultFormMessagesHelper);
        }

        if (!$this->formMessagesHelper instanceof AbstractHelper) {
            // @todo Ideally the helper should implement an interface.
            throw InvalidHelperException::invalidHelperInstance($this->formMessagesHelper);
        }

        return $this->formMessagesHelper;
    }
692909
public function getTranslateForm()
    {
        if ($this->translateForm === null) {
            $this->translateForm = $this->getServiceLocator()->get('playgroundtranslate_translate_form');
        }
        return $this->translateForm;
    }
497249
protected function getCommandInput()
    {
        $modelName = trim($this->argument('model-name'));
        $cName = trim($this->option('controller-name'));
        $controllerName = $cName ? str_finish($cName, Config::getControllerNamePostFix()) : Helpers::makeControllerName($modelName);
        $viewDirectory = $this->option('views-directory');
        $prefix = ($this->option('routes-prefix') == 'default-form') ? Helpers::makeRouteGroup($modelName) : $this->option('routes-prefix');
        $perPage = intval($this->option('models-per-page'));
        $resourceFile = trim($this->option('resource-file')) ?: Helpers::makeJsonFileName($modelName);
        $langFile = $this->option('language-filename') ?: Helpers::makeLocaleGroup($modelName);
        $withFormRequest = $this->option('with-form-request');
        $force = $this->option('force');
        $modelDirectory = $this->option('model-directory');
        $controllerDirectory = trim($this->option('controller-directory'));
        $formRequestName = Helpers::makeFormRequestName($modelName);
        $template = $this->getTemplateName();
        $formRequestDirectory = trim($this->option('form-request-directory'));
        $extends = $this->generatorOption('controller-extends');
        $withAuth = $this->option('with-auth');

        return (object) compact(
            'formRequestDirectory',
            'viewDirectory',
            'modelName',
            'prefix',
            'perPage',
            'modelDirectory',
            'langFile',
            'withFormRequest',
            'formRequestName',
            'force',
            'resourceFile',
            'template',
            'controllerName',
            'extends',
            'withAuth',
            'controllerDirectory'
        );
    }
126486
protected function getElementHelper()
    {
        if ($this->elementHelper) {
            return $this->elementHelper;
        }

        if (method_exists($this->view, 'plugin')) {
            $this->elementHelper = $this->view->plugin('form_element');
        }

        if (!$this->elementHelper instanceof FormElement) {
            $this->elementHelper = new FormElement();
        }

        return $this->elementHelper;
    }