Get all entrypoints for a designated target

@param string $target
@return Entrypoint[]
15310
public function getEntryPoints($target = self::OPTION_POSTLOGIN)
    {
        $ids = $this->hasOption($target) ? $this->getOption($target) : array();
        $existing = $this->getOption(self::OPTION_ENTRYPOINTS);

        if ($target === self::OPTION_ENTRYPOINTS) {
            return $existing;
        }

        $entryPoints = array();
        foreach ($ids as $id) {
            $entryPoints[$id] = $existing[$id];
        }
        return $entryPoints;
    }
970020
public function queueIndexingJob(string $target): array
    {
        return $this->getApi()->request(sprintf('/staff/indexing_jobs'), Request::METHOD_POST, [
                'target' => $target
            ]);
    }
448409
public function callInterventionMethods($target)
    {
        if (!empty($this->interventionCalls)) {
            $image = ImageManagerStatic::make($target);

            foreach ($this->interventionCalls as $call) {
                call_user_func_array(
                    [$image, $call['method']],
                    $call['arguments']
                )->save($target);
            }
        }

        return $target;
    }
786390
public function entrypoints()
    {
        if (is_null($this->entrypointRequests)) {
            $this->entrypointRequests = new EntrypointRequests($this->client);
        }

        return $this->entrypointRequests;
    }
925963
public static function dataGet( $target, $key, $default = NULL )
    {
        if ( is_null( $key ) ) return $target;

        foreach ( explode( '.', $key ) as $segment )
        {
            if ( is_array( $target ) )
            {
                if ( !array_key_exists( $segment, $target ) )
                {
                    return static::value( $default );
                }

                $target = $target[ $segment ];
            }
            elseif ( is_object( $target ) )
            {
                if ( !isset( $target->{$segment} ) )
                {
                    return static::value( $default );
                }

                $target = $target->{$segment};
            }
            else
            {
                return static::value( $default );
            }
        }

        return $target;
    }
1202997
public static function from($target)
    {
        return collect((new ReflectionClass($target))->getProperties())
            ->mapWithKeys(function ($property) use ($target) {
                $property->setAccessible(true);

                if (($value = $property->getValue($target)) instanceof Model) {
                    return [$property->getName() => FormatModel::given($value)];
                } elseif (is_object($value)) {
                    return [
                        $property->getName() => [
                            'class' => get_class($value),
                            'properties' => json_decode(json_encode($value), true),
                        ],
                    ];
                } else {
                    return [$property->getName() => json_decode(json_encode($value), true)];
                }
            })->toArray();
    }
932560
public function mapTarget(PersistenceTarget $target): Target
    {
        try {
            $targetType = $this->targetTypeRegistry->getTargetType(
                $target->type
            );
        } catch (TargetTypeException $e) {
            $targetType = new NullTargetType();
        }

        $targetData = [
            'id' => $target->id,
            'status' => $target->status,
            'ruleId' => $target->ruleId,
            'targetType' => $targetType,
            'value' => $target->value,
        ];

        return Target::fromArray($targetData);
    }
860888
protected function mapJoinColumns(array $target = [], array $source = [])
    {
        $joinColumns = [];
        foreach ($target as $index => $joinColumn) {
            if (isset($source[$index])) {
                $diff = array_diff($joinColumn, $source[$index]);

                if (!empty($diff)) {
                    $joinColumns[] = $diff;
                }
            }
        }

        return $joinColumns;
    }
493138
public function getSchemaEntryPoints()
	{
		return array_reduce( $this->entryPoints, function( $carry, $entryPoint ) {
			$schemaFiles = array_filter( $entryPoint['entryPointDocument'], function( $entryPointDocument ) {
				return XBRL::endsWith( $entryPointDocument, ".xsd" );
			} );
			return array_merge( $carry, $schemaFiles );
		}, array() );
	}
268641
public static function hydrateCollection(array $entrypoints)
    {
        $hydrated = [];

        foreach ($entrypoints as $entrypoint) {
            $hydrated[] = self::hydrate($entrypoint);
        }

        return $hydrated;
    }
638626
private static function callMapClass($target): \ReflectionClass
    {
        $class = self::reflect($target);
        if (!isset(self::$classes[$class->getName()])) {
            self::$classes[$class->getName()] = self::forkCallMapClass($class);
        }

        return self::$classes[$class->getName()];
    }
547423
protected function createCollection( $target )
    {
        $target = $this->splitFirstPathElement( $target, $currentSite );

        if ( !$currentSite )
        {
            // Site list cannot get new entries
            return false; // @as self::FAILED_FORBIDDEN;
        }

        return $this->mkcolVirtualFolder( $currentSite, $target );
    }
752304
protected function dataGet($target, $key)
    {
        foreach (explode('.', $key) as $segment) {
            if (is_object($target) && in_array(Revisionable::class, class_uses_recursive(get_class($target)))) {
                $target = $this->passThroughRevisionable($target, $segment);
            } elseif ($target instanceof self || $target instanceof Revision) {
                $target = $this->passThroughRevision($target, $segment);
            } elseif ($target instanceof Model) {
                $target = $this->passThroughModel($target, $segment);
            } else {
                $target = null;
            }

            if (!$target) {
                return;
            }
        }

        return $target;
    }
775157
private function getTargetParamsFromTarget( $target ) {
		if( $target instanceof EntityId ) {
			return array( 'id' => $target->getSerialization() );
		} elseif( $target instanceof SiteLink ) {
			return array(
				'site' => $target->getSiteId(),
				'title' => $target->getPageName(),
			);
		} else {
			throw new UnexpectedValueException( '$target needs to be an EntityId or SiteLink' );
		}
	}
937201
public function withTargets(Target ...$targets): self
    {
        $obj = clone $this;
        $obj->_targets = $targets;
        return $obj;
    }
816171
public function all($subject): array
    {
        $matched = [];
        foreach ($this->workflows as list($workflow, $supportStrategy)) {
            if ($supportStrategy->supports($workflow, $subject)) {
                $matched[] = $workflow;
            }
        }

        return $matched;
    }
1145106
protected static function modelsFor(array $targets)
    {
        $models = [];

        foreach ($targets as $target) {
            $models[] = collect((new ReflectionClass($target))->getProperties())->map(function ($property) use ($target) {
                $property->setAccessible(true);

                $value = $property->getValue($target);

                if ($value instanceof Model) {
                    return [$value];
                } elseif ($value instanceof EloquentCollection) {
                    return $value->flatten();
                }
            })->collapse()->filter()->all();
        }

        return collect(Arr::collapse($models))->unique();
    }