Resolves static and dynamic authors linked to this post.

@return ArrayList
182355
public function getCredits()
    {
        $list = ArrayList::create();

        $list->merge($this->getDynamicCredits());
        $list->merge($this->getStaticCredits());

        return $list->sort('Name');
    }
1123393
public function searchableFields()
    {
        $searchableFields = parent::searchableFields();
        unset($searchableFields['PublishFrom']);
        $searchableFields['Title'] = array(
            'field'  => 'TextField',
            'filter' => 'PartialMatchFilter',
            'title'  => _t('News.TITLE', 'Title')
        );
        $searchableFields['Author'] = array(
            'field'  => 'TextField',
            'filter' => 'PartialMatchFilter',
            'title'  => _t('News.AUTHOR', 'Author')
        );

        return $searchableFields;
    }
837663
public function getArtists()
    {
        if ($this->artists === null) {
            $this->artists = $this->getRelated('artists');
        }
        return $this->artists;
    }
447508
public function author()
    {
        $model = config('forum.integration.user_model');
        if (method_exists($model, 'withTrashed')) {
            return $this->belongsTo($model, 'author_id')->withTrashed();
        }

        return $this->belongsTo($model, 'author_id');
    }
20551
public function fetchPairsByResourceName(): array
	{
		$result = [];
		$rows = $this->findByResource();
		foreach ($rows as $row) {
			$result[$row->id] = $row->resource . ($this->translator ? ' - ( ' . $this->translator->translate($row->name) . ' )' : '');
		}
		return $result;
	}
1019070
public function getUseLines()
    {
        $lines = [];

        $lines = array_merge($lines, $this->getUseLinesSymfony2Part());

        $lines[] = 'use Doctrine\ORM\Mapping as ORM;';

        $useArrayCollection = false;

        foreach ($this->getEntity()->getAttributes() as $attr) {
            if (null !== $attr->getForeign() && 'array' === $attr->getType()) {
                $useArrayCollection = true;
                break;
            }
        }

        if ($useArrayCollection) {
            $lines[] = 'use Doctrine\\Common\\Collections\\ArrayCollection;';
        }


        $lines = array_merge($lines, $this->getUseLinesUserAdditionsPart());

        return $lines;
    }
200658
public static function __static()
	{
		$prefixes = array( STANDARD_PREFIX_SCHEMA, STANDARD_PREFIX_XBRLI, STANDARD_PREFIX_LINK, STANDARD_PREFIX_XLINK, STANDARD_PREFIX_GENERIC, STANDARD_PREFIX_XBRLDT, STANDARD_PREFIX_XBRLDI );
		self::$standardNamespaces = $temp = array_flip( array_intersect_key( self::$standardPrefixes, array_flip( $prefixes ) ) );

		self::$standardArcElements = array_flip(
			array(
				"definitionArc",
				"calculationArc",
				"presentationArc",
				"labelArc",
				"referenceArc",
				"footnoteArc",
			)
		);

		self::$standardLinkElements = array_flip(
			array(
				"definitionLink",
				"calculationLink",
				"presentationLink",
				"labelLink",
				"referenceLink",
				"footnoteLink",
				"label",
				"footnote",
				"reference",
			)
		);

		foreach ( self::$standardArcElements as $arc => $value )
		{
			$qname = self::qnameNS( "link:$arc" );
			self::$standardArcQnames[ (string) $qname ] = $qname;
		}

		foreach ( self::$standardLinkElements as $link => $value )
		{
			/**
			 * @var QName qname
			 */
			$qname = self::qnameNS( "link:$link" );
			self::$standardExtLinkQnamesAndResources[ (string) $qname ] = $qname;
		}

		self::$standardExtLinkQnames = array_filter(
			self::$standardExtLinkQnamesAndResources,
			function( $qname ) { return XBRL::endsWith( $qname->localName, 'Link' ); }
		);

		self::$resourceArcRoles = array_flip(
			array(
				self::$arcRoleConceptLabel,
				self::$arcRoleConceptReference,
				self::$arcRoleFactFootnote,
				self::$genericElementLabel,
				self::$genericElementReference,
			)
		);

		self::$standardLabelRoles = array(
			self::$labelRoleLabel,
			self::$labelRoleTerseLabel,
			self::$labelRoleVerboseLabel,
			self::$labelRolePositiveLabel,
			self::$labelRolePositiveTerseLabel,
			self::$labelRolePositiveVerboseLabel,
			self::$labelRoleNegativeLabel,
			self::$labelRoleNegativeTerseLabel,
			self::$labelRoleNegativeVerboseLabel,
			self::$labelRoleZeroLabel,
			self::$labelRoleZeroTerseLabel,
			self::$labelRoleZeroVerboseLabel,
			self::$labelRoleTotalLabel,
			self::$labelRolePeriodStartLabel,
			self::$labelRolePeriodEndLabel,
			self::$labelRoleDocumentation,
			self::$labelRoleDefinitionGuidance,
			self::$labelRoleDisclosureGuidance,
			self::$labelRolePresentationGuidance,
			self::$labelRoleMeasurementGuidance,
			self::$labelRoleCommentaryGuidance,
			self::$labelRoleExampleGuidance,
		);

		self::$standardRoles = array_flip(
			array_merge(
				self::$standardLabelRoles,
				self::$standardReferenceRoles,
				self::$standardLinkbaseRefRoles,
				array(
						self::$defaultLinkRole,
						self::$footnote,
				)
			)
		);

		self::$standardArcRoles = array_flip(
			array(
				self::$linkCalculationArc,
				self::$linkDefinitionArc,
				self::$linkFootnoteArc,
				self::$linkLabelArc,
				self::$linkPresentationArc,
				self::$linkReferenceArc,
			)
		);

		self::$standardArcroleCyclesAllowed = array(
			self::$arcRoleConceptLabel		=> array( "any", null ),
			self::$arcRoleConceptReference	=> array( "any", null ),
			self::$arcRoleFactFootnote		=> array( "any", null ),
			self::$arcRoleParentChild		=> array( "undirected", "xbrl.5.2.4.2" ),
			self::$arcRoleSummationItem		=> array( "any", "xbrl.5.2.5.2" ),
			self::$arcRoleGeneralSpecial	=> array( "undirected", "xbrl.5.2.6.2.1" ),
			self::$arcRoleEssenceAlias		=> array( "undirected", "xbrl.5.2.6.2.1" ),
			self::$arcRoleSimilarTuples		=> array( "any", "xbrl.5.2.6.2.3" ),
			self::$arcRoleRequiresElement	=> array( "any", "xbrl.5.2.6.2.4" ),
		);

		self::$consecutiveArcrole = array( // can be list of or single arcrole
			'all'						=> array( self::$arcRoleDimensionDomain, self::$arcRoleHypercubeDimension ),
			'notAll'					=> array( self::$arcRoleDimensionDomain, self::$arcRoleHypercubeDimension ),
			'hypercubeDimension'		=> self::$arcRoleDimensionDomain,
			'dimensionDomain'			=> array( self::$arcRoleDomainMember, self::$arcRoleAll, self::$arcRoleNotAll ),
			'domainMember'				=> array( self::$arcRoleDomainMember, self::$arcRoleAll, self::$arcRoleNotAll ),
			'dimensionDefault'			=> array(),
		);

		self::$hasHypercube = array(
			self::$arcRoleAll,
			self::$arcRoleNotAll,
		);

		self::$standardLinkbaseRefRoles = array(
			self::$CalculationLinkbaseRef,
			self::$DefinitionLinkbaseRef,
			self::$LabelLinkbaseRef,
			self::$PresentationLinkbaseRef,
			self::$ReferenceLinkbaseRef,
		);

		self::$arcCustomAttributesExclusions = array(
			'http://www.w3.org/2000/xmlns',
			self::$standardPrefixes[ STANDARD_PREFIX_XLINK ],
			"use",
			"priority",
			"order",
		);

		self::$xbrliSubstitutionHeads = array(
			self::$xbrldtDimensionItem,
			self::$xbrldtHypercubeItem,
			self::$xbrliItem,
			self::$xbrliTuple,
		);

		self::$arcRoleDimensional = array(
			XBRL_Constants::$arcRoleAll,
			XBRL_Constants::$arcRoleNotAll,
			XBRL_Constants::$arcRoleDimensionDomain,
			XBRL_Constants::$arcRoleDomainMember,
			XBRL_Constants::$arcRoleDimensionMember,
			XBRL_Constants::$arcRoleHypercubeDimension,
			XBRL_Constants::$arcRoleDimensionDefault,
		);
	}
618275
protected function sortResolvers()
    {
        $sortedResolvers = array();
        krsort($this->resolvers);

        foreach ($this->resolvers as $resolvers) {
            $sortedResolvers = array_merge($sortedResolvers, $resolvers);
        }

        return $sortedResolvers;
    }
1303286
public function resolve(): array
    {
        if (\is_array($this->schema)) {
            if (isset($this->schema['$ref'])) {
                $ref = $this->schema['$ref'];

                if ($ref === '#') {
                    return $this->rootSchema;
                }
                if (\preg_match('/^#\/[a-z0-9_-]+(\/[a-z0-9_-]+)?$/i', $ref)) {
                    $schema = $this->rootSchema;
                    $path = \explode('/', substr($ref, 2));

                    foreach ($path as $item) {
                        if (!isset($schema[$item])) {
                            throw new ResolveSchemaReferenceException($ref);
                        }
                        $schema = $schema[$item];
                    }
                    return $schema;
                }
                throw new ResolveSchemaReferenceException($ref);
            }
            return $this->schema;
        }
        if (\filter_var(
            $this->schema,
            \FILTER_VALIDATE_URL, \FILTER_FLAG_SCHEME_REQUIRED | \FILTER_FLAG_HOST_REQUIRED
        )) {
            return $this->loadSchema($this->schema);
        }
        throw new ResolveSchemaException();
    }
1059020
public function summaryFields()
    {
        $summaryFields = parent::summaryFields();
        $summaryFields = array_merge(
            $summaryFields, array(
                'Title'       => _t('News.TITLE', 'Title'),
                'Author'      => _t('News.AUTHOR', 'Author'),
                'PublishFrom' => _t('News.PUBLISH', 'Publish from'),
                'Status'      => _t('News.STATUS', 'Status'),
            )
        );

        return $summaryFields;
    }
223654
public function getModularInfo() : array
    {
        return [
            static::NAME        => $this->getModularName(),
            static::VERSION     => $this->getModularVersion(),
            static::URI         => $this->getModularUri(),
            static::AUTHOR      => $this->getModularAuthor(),
            static::AUTHOR_URI  => $this->getModularAuthorUri(),
            static::DESCRIPTION => $this->getModularDescription(),
            static::CLASS_NAME  => get_class($this),
            static::FILE_PATH   => $this->getModularRealPath(),
            static::SELECTOR    => $this->getModularNameSelector(),
        ];
    }
699733
public static function values()
    {
        $values = [];
        foreach (static::toList() as $key => $value) {
            $values[$key] = new static($value);
        }

        return $values;
    }
599693
final public static function getReadOnlyResources() {
        return [
            self::USER_GET,
            self::USER_HEAD,
            self::USER_OPTIONS,

            self::IMAGE_GET,
            self::IMAGE_HEAD,
            self::IMAGE_OPTIONS,

            self::IMAGES_GET,
            self::IMAGES_HEAD,
            self::IMAGES_OPTIONS,

            self::METADATA_GET,
            self::METADATA_HEAD,
            self::METADATA_OPTIONS,

            self::SHORTURL_GET,
            self::SHORTURL_HEAD,
            self::SHORTURL_OPTIONS,

            self::GLOBAL_IMAGES_GET,
            self::GLOBAL_IMAGES_HEAD,
            self::GLOBAL_IMAGES_OPTIONS,

            self::SHORTURLS_OPTIONS,
        ];
    }
27719
static function fetchList()
    {
        $list =& $GLOBALS['eZCollaborationList'];
        if ( isset( $list ) )
            return $list;
        $list = array();
        $activeHandlers = eZCollaborationItemHandler::activeHandlers();
        $repositories = eZCollaborationItemHandler::handlerRepositories();
        foreach ( $activeHandlers as $handler )
        {
            $handlerInstance = eZCollaborationItemHandler::instantiate( $handler, $repositories );
            if ( $handlerInstance !== null )
                $list[] = $handlerInstance;
        }
        return $list;
    }
807476
public function getValue()
    {
        $val = $this->base['value'];

        if (is_array($val)) {
            if (isset($val['ID'])) {
                return $this->authorFactory->create($val['ID']);
            } else {
                $authors = array();

                foreach ($val as $a) {
                    $authors[] = $this->authorFactory->create($a['ID']);
                }

                return $authors;
            }
        } else {
            if (isset($this->base['multiple']) && $this->base['multiple']) {
                return array();
            } else {
                return null;
            }
        }
    }
383560
public static function staticPages()
    {
        if (!getConfig('sitemap.static_pages')) {
            return [];
        }

        return array_map(function (Entity $page) {
            return self::parse(['_name' => 'page', $page->slug], ['lastmod' => $page->modified]);
        }, StaticPage::all());
    }
162017
public static function values()
    {
        $values = array();
        foreach (static::toArray() as $key => $value) {
            $values[$key] = new static($value);
        }
        return $values;
    }