芝麻web文件管理V1.00

编辑当前文件:/home/pulsehostuk9/www/portal.pulsehost.co.uk/vendor/jms/serializer/src/JMS/Serializer/Context.php

<?php

namespace JMS\Serializer;

use JMS\Serializer\Exception\RuntimeException;
use JMS\Serializer\Exclusion\DepthExclusionStrategy;
use JMS\Serializer\Exclusion\DisjunctExclusionStrategy;
use JMS\Serializer\Exclusion\ExclusionStrategyInterface;
use JMS\Serializer\Exclusion\GroupsExclusionStrategy;
use JMS\Serializer\Exclusion\VersionExclusionStrategy;
use JMS\Serializer\Metadata\ClassMetadata;
use JMS\Serializer\Metadata\PropertyMetadata;
use Metadata\MetadataFactory;
use Metadata\MetadataFactoryInterface;
use PhpCollection\Map;

abstract class Context
{
    /**
     * @deprecated use has/get/set attribute methods
     * @var \PhpCollection\Map
     */
    public $attributes;

private $format;

/** @var VisitorInterface */
    private $visitor;

/** @var GraphNavigator */
    private $navigator;

/** @var MetadataFactory */
    private $metadataFactory;

/** @var ExclusionStrategyInterface */
    private $exclusionStrategy;

/** @var boolean|null */
    private $serializeNull;

private $initialized = false;

/** @var \SplStack */
    private $metadataStack;

public function __construct()
    {
        $this->attributes = new Map();
        $this->metadataStack = new \SplStack();
    }

/**
     * @param string $format
     */
    public function initialize($format, VisitorInterface $visitor, GraphNavigator $navigator, MetadataFactoryInterface $factory)
    {
        if ($this->initialized) {
            throw new \LogicException('This context was already initialized, and cannot be re-used.');
        }

$this->initialized = true;
        $this->format = $format;
        $this->visitor = $visitor;
        $this->navigator = $navigator;
        $this->metadataFactory = $factory;
        $this->metadataStack = new \SplStack();
    }

/**
     * @deprecated  Will be removed in 2.0, Use getNavigator()->accept() instead
     * @param $data
     * @param array|null $type
     * @return mixed
     */
    public function accept($data, array $type = null)
    {
        return $this->navigator->accept($data, $type, $this);
    }

public function getMetadataFactory()
    {
        return $this->metadataFactory;
    }

public function getVisitor()
    {
        return $this->visitor;
    }

public function getNavigator()
    {
        return $this->navigator;
    }

public function getExclusionStrategy()
    {
        return $this->exclusionStrategy;
    }

public function hasAttribute($key)
    {
        return $this->attributes->get($key)->isDefined();
    }

public function getAttribute($key)
    {
        return $this->attributes->get($key)->get();
    }

public function setAttribute($key, $value)
    {
        $this->assertMutable();
        $this->attributes->set($key, $value);

return $this;
    }

private function assertMutable()
    {
        if (!$this->initialized) {
            return;
        }

throw new \LogicException('This context was already initialized and is immutable; you cannot modify it anymore.');
    }

public function addExclusionStrategy(ExclusionStrategyInterface $strategy)
    {
        $this->assertMutable();

if (null === $this->exclusionStrategy) {
            $this->exclusionStrategy = $strategy;

return $this;
        }

if ($this->exclusionStrategy instanceof DisjunctExclusionStrategy) {
            $this->exclusionStrategy->addStrategy($strategy);

return $this;
        }

$this->exclusionStrategy = new DisjunctExclusionStrategy(array(
            $this->exclusionStrategy,
            $strategy,
        ));

return $this;
    }

/**
     * @param integer $version
     */
    public function setVersion($version)
    {
        if (null === $version) {
            throw new \LogicException('The version must not be null.');
        }

$this->attributes->set('version', $version);
        $this->addExclusionStrategy(new VersionExclusionStrategy($version));

return $this;
    }

/**
     * @param array|string $groups
     */
    public function setGroups($groups)
    {
        if (empty($groups)) {
            throw new \LogicException('The groups must not be empty.');
        }

$this->attributes->set('groups', (array)$groups);
        $this->addExclusionStrategy(new GroupsExclusionStrategy((array)$groups));

return $this;
    }

public function enableMaxDepthChecks()
    {
        $this->addExclusionStrategy(new DepthExclusionStrategy());

return $this;
    }

/**
     * Set if NULLs should be serialized (TRUE) ot not (FALSE)
     *
     * @param bool $bool
     * @return $this
     */
    public function setSerializeNull($bool)
    {
        $this->serializeNull = (boolean)$bool;

return $this;
    }

/**
     * Returns TRUE when NULLs should be serialized
     * Returns FALSE when NULLs should not be serialized
     * Returns NULL when NULLs should not be serialized,
     * but the user has not explicitly decided to use this policy
     *
     * @return bool|null
     */
    public function shouldSerializeNull()
    {
        return $this->serializeNull;
    }

/**
     * @return string
     */
    public function getFormat()
    {
        return $this->format;
    }

public function pushClassMetadata(ClassMetadata $metadata)
    {
        $this->metadataStack->push($metadata);
    }

public function pushPropertyMetadata(PropertyMetadata $metadata)
    {
        $this->metadataStack->push($metadata);
    }

public function popPropertyMetadata()
    {
        $metadata = $this->metadataStack->pop();

if (!$metadata instanceof PropertyMetadata) {
            throw new RuntimeException('Context metadataStack not working well');
        }
    }

public function popClassMetadata()
    {
        $metadata = $this->metadataStack->pop();

if (!$metadata instanceof ClassMetadata) {
            throw new RuntimeException('Context metadataStack not working well');
        }
    }

public function getMetadataStack()
    {
        return $this->metadataStack;
    }

/**
     * @return array
     */
    public function getCurrentPath()
    {
        if (!$this->metadataStack) {
            return array();
        }

$paths = array();
        foreach ($this->metadataStack as $metadata) {
            if ($metadata instanceof PropertyMetadata) {
                array_unshift($paths, $metadata->name);
            }
        }

return $paths;
    }

abstract public function getDepth();

/**
     * @return integer
     */
    abstract public function getDirection();
}