Get Synthesize Method

Sets up and returns the synthesize object.
@return \Frozensheep\Synthesize
324561
public function getSynthesize(){
		if(!$this->_objSynthesize instanceof Synthesize){
			$this->_objSynthesize = $this->_createSynthesize();
		}

		return $this->_objSynthesize;
    }
167961
public function getInitOptionsResolver()
    {
        if (null === $this->initOptionsResolver) {
            if (null !== $this->parent) {
                $this->initOptionsResolver = clone $this->parent->getInitOptionsResolver();
            } else {
                $this->initOptionsResolver = new OptionsResolver();
            }

            $this->innerType->setInitOptions($this->initOptionsResolver);

            foreach ($this->typeExtensions as $extension) {
                $extension->setInitOptions($this->initOptionsResolver);
            }
        }

        return $this->initOptionsResolver;
    }
328975
public function prepareModelCrudeSetup()
    {
        $crudeName = $this->getCalledClassName();
        $modelAttr = array_merge(['id'], $this->model->getFillable(), ['created_at']);

        foreach ($modelAttr as $attr)
            $this->scope[$attr] = $this->model->getTable() . '.' . $attr;

        $this->crudeSetup = new CrudeSetup($crudeName, $modelAttr);

        if ($this->cannotUpdate())
            $this->crudeSetup->lockEditOption();

        if ($this->cannotStore('check with permission'))
            $this->crudeSetup->lockAddOption();

        if ($this->cannotDelete())
            $this->crudeSetup->lockDeleteOption();

        if ($this->cannotOrder())
            $this->crudeSetup->lockOrderOption();

        $this->crudeSetup->setFilters(['id']);

        return $this->crudeSetup;
    }
1102289
public function getProducedAt() : ?string 
    {
        if ( ! $this->hasProducedAt()) {
            $this->setProducedAt($this->getDefaultProducedAt());
        }
        return $this->producedAt;
    }
1023120
public function getProxyGenerator()
    {
        if (!$this->proxyGenerator) {
            $this->proxyGenerator = new ServiceProxyGenerator($this->getProxyDir(), $this->getProxyNs());
        }
        
        return $this->proxyGenerator;
    }
1187962
public static function get()
    {
        $instance = new static;

        $request = new Request($instance->functionCall, $instance->module);        

        $instance->fill($request->execute());

        return $instance;
    }
62493
protected function buildFormzConfiguration()
    {
        $configuration = $this->typoScriptService->getFormzConfiguration();
        $instance = ConfigurationObjectFactory::getInstance()
            ->get(Configuration::class, $configuration);

        /** @var Configuration $instanceObject */
        $instanceObject = $instance->getObject(true);
        $instanceObject->calculateHash();

        return $instance;
    }
1259139
public function getConfigurationObject()
    {
        if (null === $this->configurationObject
            || $this->lastConfigurationHash !== $this->formObject->getHash()
        ) {
            $this->lastConfigurationHash = $this->formObject->getHash();
            $this->configurationObject = $this->getConfigurationObjectFromCache();
        }

        return $this->configurationObject;
    }
378259
public static function getInstance()
    {
        if (is_null(self::$instance)) {
            throw new \RuntimeException('You must first create the singleton instance with createInstance().');
        }
        self::$instance->setGlobalsFromSugar();
        self::$instance->chdirToSugarDir();

        return self::$instance;
    }
1146098
public function generate()
    {
        $indentation = $this->getIndentation();

        $docLines = array();

        $docLines[] = $indentation . '/**';
        $spaceBeforeAnnotation = false;

        if ($this->shortDescription !== null) {
            $docLines[] = $indentation . ' * ' . $this->shortDescription;
            $spaceBeforeAnnotation = true;
        }

        if ($this->shortDescription !== null && $this->longDescription !== null) {
            $docLines[] = $indentation . ' *';
        }

        if ($this->longDescription !== null) {
            $description = preg_split('/\n|\r/', $this->longDescription, -1, PREG_SPLIT_NO_EMPTY);
            foreach ($description as $desc) {
                $docLines[] = $indentation . ' * ' . trim($desc);
            }

            $spaceBeforeAnnotation = true;
        }

        $this->annotationGenerator->setIndentationLevel($this->getIndentationLevel());
        $this->annotationGenerator->setIndentationString($this->getIndentationString());
        $annotations = $this->annotationGenerator->generate();
        if ($annotations !== '') {
            if ($spaceBeforeAnnotation === true) {
                $docLines[] = $indentation . ' *';
            }

            $docLines[] = $annotations;
        }

        $docLines[] = $indentation . ' */';

        return implode($this->getLineFeed(), $docLines);
    }
79431
public function build(): SetProduceCompilationCacheRequest
	{
		$instance = new SetProduceCompilationCacheRequest();
		if ($this->enabled === null) {
			throw new BuilderException('Property [enabled] is required.');
		}
		$instance->enabled = $this->enabled;
		return $instance;
	}
873496
public function get()
	{
		// if at least an item is available in the pool
		if ( count($this->_poolItems) )
			$item = array_pop($this->_poolItems);
		
		// otherwise, we create a new instance
		else
			$item = call_user_func_array($this->_factorymethod, $this->_factorymethodparams);

		// now in use
		$this->_inUseItems[] = $item;
		
		// initialize item
		if ( $this->_initmethod )
			$item->{$this->_initmethod}();
			
		return $item;
	}
489256
public function generate()
    {
        $code = array();

        if ($this->namespace !== null) {
            $code[] = $this->getIndentation() . 'namespace ' . $this->namespace;
            $code[] = '{';
            $code[] = null;

            // Temporarily add one more level of indentation.
            $this->addIndentationLevel(1);
        }

        $doc = $this->generateDocumentation();
        if ($doc !== null) {
            $code[] = $doc;
        }

        $code[] = $this->generateSignature();
        $code[] = $this->getIndentation() . $this->generateBody();

        if ($this->namespace !== null) {
            // Set back the indentation.
            $this->addIndentationLevel(-1);

            $code[] = $this->getIndentation() . '}';
        }

        return implode($this->getLineFeed(), $code);
    }
937422
public function build(): GetDocumentRequest
	{
		$instance = new GetDocumentRequest();
		$instance->depth = $this->depth;
		$instance->pierce = $this->pierce;
		return $instance;
	}
1029384
protected function prepareInput()
    {
        $arguments = [
            '--optimize' => (bool) $this->file->get(self::SETTING_OPTIMIZE),
            '--no-dev'   => true,
        ];

        $input = new ArrayInput($arguments);
        $input->setInteractive(false);

        return $input;
    }
378801
public function getCompiler()
    {
        if ($this->compiler === null) {
            $this->compiler = new Compiler($this->sdopx, $this);
        }
        return $this->compiler;
    }
91800
public function getReflection()
	{
		if($this->reflection === NULL)
		{
			if(is_array($this->callback))
			{
				$this->reflection = (new \ReflectionClass($this->callback[0]))->getMethod($this->callback[1]);
			}
			elseif(is_object($this->callback) && !$this->callback instanceof \Closure)
			{
				$this->reflection = (new \ReflectionClass($this->callback))->getMethod('__invoke');
			}
			else
			{
				$this->reflection = new \ReflectionFunction($this->callback);
			}
		}
		
		return $this->reflection;
	}