checks if a property should be in the output

@param string          $property
@param WriterInterface $writer

@return bool
558676
public function isOutputProperty(string $property, WriterInterface $writer) : bool
    {
        if (!$this->propertyHolder->isOutputProperty($property, $writer)) {
            return false;
        }

        return in_array($property, $this->fields);
    }
838610
public function setOutput($output, $lock = false)
    {
        if ($this->outputLocked) {
            return false;
        }
        
        if ($lock) {
            $this->outputLocked = true;
        }
        
        $this->output = $output;
        return true;
    }
317848
protected function has($property, ...$properties)
    {
        if (is_array($property)) {
            $properties = $property;
        } else {
            $properties[] = $property;
        }

        foreach ($properties as $property) {
            $property = $this->translateProperty($property);
            if (!isset($this->{$property})) {
                return false;
            }
        }

        return true;
    }
611092
private function isGetOptionsAllowed(PropertyInterface $property): bool
    {
        $propExtra = $property->getExtra();

        // Check the overwrite param.
        if (\is_array($propExtra)
            && \array_key_exists('fetchOptions', $propExtra)
            && (true === $propExtra['fetchOptions'])
        ) {
            return true;
        }

        // Check the class.
        if ('checkbox' !== $property->getWidgetType()) {
            return true;
        }

        // Check if multiple is active.
        return \array_key_exists('multiple', $propExtra) && (true === $propExtra['multiple']);
    }
47448
private function add(Writer $writer, array $properties)
    {
        foreach ($properties as $property) {
            if (! is_null($this->$property)) {
                $writer->write([$property => $this->$property]);
            }
        }
    }
988416
private function propertyIsIgnored(string $type, string $propertyName): bool
    {
        return isset($this->ignoredEncodedPropertyNamesByType[$type][$this->normalizePropertyName($propertyName)]);
    }
1113451
public function isActivatedBy(InputInterface $input, OutputInterface $output): bool
    {
        foreach ($this->constraints as $constraint) {
            if (!$constraint->accepts($input, $output)) {
                return false;
            }
        }
        return true;
    }
841195
public function setWriter(\Parable\Log\Writer\WriterInterface $writer)
    {
        $this->writer = $writer;
        return $this;
    }
35307
protected function hasProperty(string $resourceClass, string $property): bool
    {
        return \in_array($property, iterator_to_array($this->getProperties($resourceClass)), true);
    }
335724
public function hasProperty($propertyIdent)
    {
        if (!is_string($propertyIdent)) {
            throw new InvalidArgumentException(
                'Property identifier must be a string.'
            );
        }

        $metadata   = $this->metadata();
        $properties = $metadata->properties();

        return isset($properties[$propertyIdent]);
    }
807965
protected function checkPermission(OutputInterface $output)
    {
        $output->writeln(array(
            "Checking some permissions"
        ));

        /** @var Translator $translator */
        $translator = $this->getContainer()->get('thelia.translator');

        $permissions = new CheckPermission(false, $translator);
        $isValid = $permissions->exec();

        foreach ($permissions->getValidationMessages() as $item => $data) {
            if ($data['status']) {
                $output->writeln(
                    array(
                        sprintf(
                            "<info>%s ...</info> %s",
                            $data['text'],
                            "<info>Ok</info>"
                        )
                    )
                );
            } else {
                $output->writeln(array(
                    sprintf(
                        "<error>%s </error>%s",
                        $data['text'],
                        sprintf("<error>%s</error>", $data["hint"])
                    )
                ));
            }
        }

        if (false === $isValid) {
            throw new \RuntimeException('Please put correct permissions and reload install process');
        }
    }
419303
public function hasProperty($property, $lazyLoad = true)
    {
        if (!$this->isProperty($property)) {
            return false;
        }
        if (!array_key_exists($property, $this->data) && $lazyLoad) {
            $this->ensureFull();
        }

        return array_key_exists($property, $this->data);
    }
1037324
protected function resolveStringWriter($writer)
    {
        if (is_string($writer) && array_key_exists($writer, $this->writers)) {
            return $this->writers[$writer];
        }

        return false;
    }
224124
protected function checkProperty(OutputInterface $output, CheckInterface $property)
    {
        $result = $property->check();

        if ($result === false) {
            $outputLevel = 'error';
            $sign = self::EMOJI_FAILURE;

            if ($property->isOptional() === true) {
                $outputLevel = 'comment';
                $sign = self::EMOJI_OPTIONAL;
            }

            $message = $property->getFailureMessage();

            // The default value from overallResult is true.
            // So it is enough to set it to false once.
            $this->overallResult = false;

        } elseif ($result === true) {
            $outputLevel = 'info';
            $sign = self::EMOJI_OK;
            $message = $property->getSuccessMessage();
        }

        $outputMessage = "  <info>%s</info>   <%s>%s</%s>";
        $outputMessage = sprintf($outputMessage, $sign, $outputLevel, $message, $outputLevel);
        $output->writeln($outputMessage);

        return $result;
    }
237
public function __isset($property)
    {
        if ($propertyReflector = $this->liberatorPropertyReflector($property)) {
            return null !== $propertyReflector->getValue($this->popsValue());
        }

        return parent::__isset($property);
    }
366059
private function isPropertyAllowedByIntersectProperties(
        PropertyInterface $property,
        EnvironmentInterface $environment
    ) {
        $sessionStorage = $environment->getSessionStorage();
        $inputProvider  = $environment->getInputProvider();
        $dataDefinition = $environment->getDataDefinition();

        $session = $sessionStorage->get($dataDefinition->getName() . '.' . $inputProvider->getParameter('mode'));

        return \array_key_exists($property->getName(), $session['intersectProperties']);
    }
1282760
public function hasProperty($property)
    {
        if (property_exists($this, $property) || !is_null($this->data($property))) {
            return true;
        }

        return false;
    }