Begin executing a new tags operation if the store supports it.

@param  array|mixed $names
@return TaggedCache

@throws \BadMethodCallException
185325
public function tags( $names )
	{
		if ( method_exists( $this->store, 'tags' ) )
		{
			$taggedCache = $this->store->tags( $names );
			$taggedCache->setDefaultCacheTime( $this->default );

			return $taggedCache;
		}

		throw new BadMethodCallException( 'This cache store does not support tagging.' );
	}
25905
public static function startTag($name, $attributes, $emptyTag = false)
    {
        $buffer = '<' . $name;
        $buffer .= static::attributes($attributes);
        $buffer .= $emptyTag ? '/>' : '>';

        return $buffer;
    }
674571
public function reset( array $names = array() )
    {
        if( array() == $names )
        {
            // Unset new instance to force reset
            $this->new_instance = array();
            return $this->update();
        }
        else
        {
            foreach( $this->components as $c )
            {
                if( in_array($c->get_name(), $names) )
                {
                    $this->new_instance[$c->get_name()] = $c->get_default_value();
                }
            }
            return $this->update();
        }
    }
448584
protected function newMethodSegment($name, array $arguments = [])
    {
        return $this->provider->createQueryable($this->newMethod($name, $arguments));
    }
731656
public function start($key, array $tags=[])
    {
        if ($this->isExists($key)) {
            throw new TimerExistException('The Timer is allready started: '. $key);
        }

        $this->setTimer($key, $this->pinba()->timerStart($tags));

        return $this;
    }
501571
static public function add($tag,$name) {
        if(!isset(self::$tags[$tag])){
            self::$tags[$tag]   =   array();
        }
        if(is_array($name)){
            self::$tags[$tag]   =   array_merge(self::$tags[$tag],$name);
        }else{
            self::$tags[$tag][] =   $name;
        }
    }
1150132
public function createNew(
        string $name,
        array $tags
    ) : array {
        $array = [
            'name' => $name,
            'tags' => $tags
        ];

        return $this->sendPost(
            sprintf('/profiles/%s/sources', $this->userName),
            [],
            $array
        );
    }
1370709
public static function invalidate($cache, $tags): void
    {
        $keys = [];
        foreach ((array) $tags as $tag) {
            $keys[] = static::buildCacheKey($tag);
        }
        static::touchKeys($cache, $keys);
    }
180308
public static function setNames(array $names)
    {
        if(static::$isInited)
        {
            throw new \RuntimeException('addName failed, MemoryTableManager was inited');
        }
        foreach($names as $key => $value)
        {
            if(is_numeric($key))
            {
                static::$tables[$value] = 0;
            }
            else
            {
                static::$tables[$key] = $value;
            }
        }
    }
498363
protected function setTagItem(string $name): void
    {
        if (!empty($this->tag)) {
            foreach ($this->tag as $tag) {
                $tagName = $this->getTagKey($tag);
                $this->handler->sAdd($tagName, $name);
            }

            $this->tag = null;
        }
    }
45581
public function attachTags($tags)
    {
        // Use 'sync' not 'attach' to avoid Integrity constraint violation
        $this->tags()->sync($this->parseTags($tags), false);

        return $this;
    }
236799
protected function setTags($key, array $tags = [])
    {
        if (empty($tags)) {
            return;
        }

        foreach ($this->prepareTags($tags) as $tag) {
            $this->storage->sAdd($tag, $key);
        }
    }
848768
public function cache($id = null, $tags = [])
    {
        $this->_shouldCache = $id === false ? false : true;
        $this->_cacheId = is_string($id) ? $id : $this->_cacheId;
        $this->_cacheTags = $tags ? (array) $tags : $this->_cacheTags;

        return $this;
    }
714082
public static function tag( $name, $param1 = null, $param2 = null ) 
	{
		return static::create( $name, $param1, $param2 );
	}
1278430
public function syncTags($tags, bool $detaching = true)
    {
        $this->tags()->sync($this->parseTags($tags, null, null, true), $detaching);

        return $this;
    }
342964
public function tagId($name)
    {
        return $this->store->get($this->tagKey($name)) ?: $this->resetTag($name);
    }
713359
public function flushCachesByTag(string $tag, bool $flushPersistentCaches = false): void
    {
        $this->createAllCaches();
        /** @var FrontendInterface $cache */
        foreach ($this->caches as $identifier => $cache) {
            if (!$flushPersistentCaches && $this->isCachePersistent($identifier)) {
                continue;
            }
            $cache->flushByTag($tag);
        }
    }