Internal evaluation if given configuration is renderable.

@param array $fusionConfiguration
@return boolean
486722
protected function canRenderWithConfiguration(array $fusionConfiguration)
    {
        if ($this->hasExpressionOrValue($fusionConfiguration)) {
            return true;
        }

        if (isset($fusionConfiguration['__meta']['class']) && isset($fusionConfiguration['__objectType'])) {
            return true;
        }

        return false;
    }
495202
protected function renderContent(ControllerContext $controllerContext)
    {
        $cacheTags = $this->cachingHelper->nodeTag($this->getNode());
        foreach ($cacheTags as $tag) {
            $this->contentCache->flushByTag($tag);
        }

        $nodeDomAddress = $this->getNodeDomAddress();

        $fusionView = new FusionView();
        $fusionView->setControllerContext($controllerContext);

        $fusionView->assign('value', $this->getNode());
        $fusionView->setFusionPath($nodeDomAddress->getFusionPath());

        return $fusionView->render();
    }
225450
public function isDisabled()
    {
        // Disable (if no enabled buttons):
        
        if (!$this->getEnabledButtons()->exists()) {
            return true;
        }
        
        // Disable (if no current page):
        
        if (!($page = $this->getCurrentPage(Page::class))) {
            return true;
        }
        
        // Disable (if disabled for page class):
        
        if (in_array(get_class($page), $this->config()->disabled_on)) {
            return true;
        }
        
        // Enable (if sharing is not disabled for page):
        
        return !$page->isSharingDisabled() ? parent::isDisabled() : true;
    }
147555
public static boolean isRenderableFile(Resource resource) {
        boolean result = false;
        try {
            Node node = resource.adaptTo(Node.class);
            if (node != null) {
                NodeType type = node.getPrimaryNodeType();
                if (ResourceUtil.TYPE_FILE.equals(type.getName())) {
                    String resoureName = resource.getName();
                    result = resoureName.toLowerCase().endsWith(LinkUtil.EXT_HTML);
                }
            }
        } catch (RepositoryException e) {
            // ok, not renderable
        }
        return result;
    }
258356
public function hasTemplate()
    {
        try {
            $this->baseRenderingContext->getTemplatePaths()->getTemplateSource(
                $this->baseRenderingContext->getControllerName(),
                $this->baseRenderingContext->getControllerAction()
            );

            return true;
        } catch (InvalidTemplateResourceException $e) {
            return false;
        }
    }
616351
private function parseConfiguration($configuration)
    {
        $return = [];
        foreach ($configuration as $page) {
            foreach ($page as $key => $setting) {
                if ($key == 'helpers') {
                    foreach ($setting as $a => $b) {
                        if (!isset($return['renderers'])) {
                            $return['renderers'] = array();
                        }
                        if (!isset($return['renderers'][$a])) {
                            $return['renderers'][$a] = array();
                        }
                        if (!isset($return['renderers'][$a]['helpers'])) {
                            $return['renderers'][$a]['helpers'] = array();
                        }
                        $return['renderers'][$a]['helpers'] = array_replace($return['renderers'][$a]['helpers'], $b);
                    }
                } else {
                    $return[$key] = $setting;
                }
            }
        }
        return $return;
    }
1332173
public function handleRenderingException($fusionPath, \Exception $exception)
    {
        if ($exception instanceof StopActionException || $exception instanceof SecurityException) {
            throw $exception;
        }
        if ($exception instanceof Exceptions\RuntimeException) {
            $fusionPath = $exception->getFusionPath();
            $exception = $exception->getPrevious();
        }
        if ($this->exceptionDisablesCache($fusionPath, $exception)) {
            $this->runtime->setEnableContentCache(false);
        }
        $referenceCode = ($exception instanceof \Neos\Flow\Exception) ? $exception->getReferenceCode() : null;
        return $this->handle($fusionPath, $exception, $referenceCode);
    }
743780
public function getonedbActivity(string $dbconfiguration):Renderer
    {
        $file = (array) JL::open(FEnv::get("framework.config.db.file"));
        foreach ($file as $one => $val) {
            if ($one == $dbconfiguration) {
                return ((new Renderer())->jsonRenderer(array("code" => 200, "results" => $val)));
            }
        }

        return ((new Renderer())->jsonRenderer(array("code" => 200, "results" => array())));
    }
733167
public boolean isRenderLabel() {
		return (boolean) (Boolean) getStateHelper().eval(PropertyKeys.renderLabel, net.bootsfaces.component.ComponentUtils.isRenderLabelDefault());
	}
294317
public function renderValues($content, array $configuration = null)
    {
        if (empty($configuration['values.'])) {
            return;
        }

        $as = (!empty($configuration['as']) ? $configuration['as'] : null);
        $this->addSection($this->stdWrapValues($configuration['values.']), $as);
    }
983138
public function isDisplayable() {
        $displayable = $this->enable && $this->visible;
        if (true === $displayable) {
            return true;
        }
        foreach ($this->getNodes() as $current) {
            if (false === ($current instanceof AbstractNavigationNode)) {
                continue;
            }
            if (true === $current->isDisplayable()) {
                return true;
            }
        }
        return $displayable;
    }
806420
public function shouldRenderClientSide($options)
    {
        if (isset($options['rendering'])) {
            if (in_array($options['rendering'], ['client_side', 'both'], true)) {
                return true;
            } else {
                return false;
            }
        }

        return $this->renderClientSide;
    }
710201
public function render($fusionPath)
    {
        try {
            $output = $this->evaluateInternal($fusionPath, self::BEHAVIOR_EXCEPTION);
            if ($this->debugMode) {
                $output = sprintf('%1$s<!-- Beginning to render TS path "%2$s" (Context: %3$s) -->%4$s%1$s<!-- End to render TS path "%2$s" (Context: %3$s) -->',
                    chr(10),
                    $fusionPath,
                    implode(', ', array_keys($this->getCurrentContext())),
                    $output
                );
            }
        } catch (SecurityException $securityException) {
            throw $securityException;
        } catch (\Exception $exception) {
            $output = $this->handleRenderingException($fusionPath, $exception);
        }

        return $output;
    }
101538
public function isEnable()
    {
        if (!$this->mPDFExists() || !$this->collection()->getSize()) {
            return false;
        }

        return $this->hasConfig(self::ENABLE);
    }
1085610
protected function evaluteExpressionOrValueInternal($fusionPath, $fusionConfiguration, $cacheContext, $contextObject)
    {
        if ($this->evaluateIfCondition($fusionConfiguration, $fusionPath, $contextObject) === false) {
            $this->finalizePathEvaluation($cacheContext);
            $this->lastEvaluationStatus = self::EVALUATION_SKIPPED;

            return null;
        }

        $evaluatedExpression = $this->evaluateEelExpressionOrSimpleValueWithProcessor($fusionPath, $fusionConfiguration, $contextObject);
        $this->finalizePathEvaluation($cacheContext);

        return $evaluatedExpression;
    }
1335563
public function requireIfNotAvailableAnd(Configuration $configuration, array $params)
  {
    $requiredIfNotAvailable = $configuration->getOptions()->getRequiredIfNotAvailable();

    if (is_array($requiredIfNotAvailable->getAnd()) && count($requiredIfNotAvailable->getAnd()) > 0)
    {
      foreach ($requiredIfNotAvailable->getAnd() as $key)
      {
        if (array_key_exists(strtolower($key), $params))
        {
          return false;
          break;
        }
      }

      return true;
    }

    return false;
  }
805413
public function mergeConfiguration(array $configuration)
    {
        if (isset($configuration['type'])) {
            try {
                $newType = $this->attributeTypeRegistry->getType($configuration['type']);
            } catch (\UnexpectedValueException $e) {
                $attributeTypeCodes = implode(', ', array_keys($this->attributeTypeRegistry->getTypes()));
                $m = "The attribute {$this->code} has an unknown type '{$configuration['type']}'.\n";
                $m .= "Available types are: {$attributeTypeCodes}";
                throw new AttributeConfigurationException($m, 0, $e);
            }
            if ($this->type && $this->type->getDatabaseType() !== $newType->getDatabaseType()) {
                $e = "The attribute '{$this->code}' cannot be overridden with a new attribute type that don't match ";
                $e .= "the database type '{$this->type->getDatabaseType()}'";
                throw new AttributeConfigurationException($e);
            }
            $this->type = $newType;
            unset($configuration['type']);
        }

        $accessor = PropertyAccess::createPropertyAccessor();
        foreach ($configuration as $key => $value) {
            try {
                $accessor->setValue($this, $key, $value);
            } catch (\Exception $e) {
                throw new AttributeConfigurationException(
                    "The attribute {$this->code} has an invalid configuration for option '{$key}'",
                    0,
                    $e
                );
            }
        }

        $this->type->setAttributeDefaults($this); // Allow attribute type service to configure attribute

        $this->checkConflicts();
    }