Filter FQCN.

@param string   $fqcn
@param callable $callback

@return string
483758
protected function filterFullQualifyClassName($fqcn, callable $callback)
    {
        $parts = explode('\\', $fqcn);

        foreach ($parts as &$part) {
            $part = call_user_func($callback, $part);
        }

        return implode('\\', $parts);
    }
797045
public function filter( $callback ) {

			$result = [];

			if ( is_callable( $callback ) ) {

				for ( $i=0; $i<$this->len; $i++ ) {
					if ( call_user_func( $callback, $this->items[$i], $i, $this ) ) {
						$result[] = &$this->items[$i];
					}
				}

			}

			$myName = get_class();

			return new $myName( $result );

		}
761608
public static function filterReferences($content, $callback, $limit = -1, &$count = 0)
    {
        $content = static::filterUrls($content, $callback, $limit, $count);
        $content = static::filterImports($content, $callback, $limit, $count, false);
        $content = static::filterIEFilters($content, $callback, $limit, $count);

        return $content;
    }
987487
private final static function loadClass($fqcn)
    {
        $reflectionClass = new ReflectionClass($fqcn);
        $constants       = $reflectionClass->getConstants();

        foreach ($constants as $name => $value) {
            $instance = new $fqcn($fqcn, $name, $value);

            /* @var $instance Enum */
            if (is_callable([$instance, '__initEnum'])) {
                $instance->__initEnum();
            }

            $instanceConstructorName = '__' . $name;
            if (is_callable([$instance, $instanceConstructorName])) {
                $instance->$instanceConstructorName();
            }

            if (!isset(self::$instances[$fqcn])) {
                self::$instances[$fqcn] = [];
            }

            self::$instances[$fqcn][$name] = $instance;
        }
    }
422067
private function _sort(callable $callback = null) : array
    {
        $values = $this->getValues();
        if ($callback){
            usort($values, $callback);
        }
        else{
            sort($values);
        }
        return $values;
    }
990707
public function listen($callback) {
		if ($this->listening) {
			$this->connection->read(function ($line) use ($callback) {
				$this->checkForError($line);
				$change = $this->parseChangeLine($line);
				if ($change) {
					return $callback($change);
				}
			});
		}
	}
341296
private function _first(callable $callback = null)
    {
        $values = $this->getValues();
        if ($callback){
            foreach($values as $key => $value){
                if ($callback($value, $key)){
                    return $value;
                }
            }
        }
        else{
            return empty($values) ? null : $values[0];
        }
        return null;
    }
1091171
public function filter(callable $callback, $resetKeys = true) {
		$array = array_filter($this->getArrayCopy(), $callback);
		return new static($resetKeys ? array_values($array) : $array);
	}
1318825
public function filter(\Closure $callback)
    {
        $collection = new static();

        foreach ($this as $element) {
            if ($callback($element)) {
                $collection->attach($element);
            }
        }

        return $collection;
    }
1130100
public function filter(\Closure $callback = null) : Collection
    {
        if ($callback) {
            return static::create(array_filter($this->data, $callback));
        }

        return static::create(array_filter($this->data));
    }
1295983
public function reject($callback = true)
    {
        $useAsCallable = $this->useAsCallable($callback);

        return $this->filter(function ($value, $key) use ($callback, $useAsCallable) {
            return $useAsCallable
                ? ! $callback($value, $key)
                : $value != $callback;
        });
    }
593027
public function filterCallback(callable $fn): ArrayObjectInterface
    {
        return new static(
            array_values(
                array_filter(
                    $this->isCollection() ? $this->data : [$this->data],
                    function($item) use ($fn) {
                        return $fn($this->box($item));
                    }
                )
            )
        );
    }
607905
public function filter($callback)
    {
        $this->assertMutable('Attempting to filter immutable array');
        $this->filters[] = $callback;
        $this->applyFilters();
        return $this;
    }
943064
public function filter($callback)
    {
        if (!is_callable($callback)) {
            throw new \InvalidArgumentException('Filter is not callable!');
        }

        $attributes = array_filter($this->attributes, $callback);
        $list = new self();
        $list->assign($attributes);

        return $list;
    }
895549
public function filter($callback)
    {
        $filter = array_values(array_filter($this->models, $callback));
        return new ModelResult($this->model_class, $filter);
    }
1327049
public static function filterIEFilters($content, $callback)
    {
        $pattern = static::REGEX_IE_FILTERS;

        return static::filterCommentless($content, function ($part) use (& $callback, $pattern) {
            return preg_replace_callback($pattern, $callback, $part);
        });
    }
1293152
public function removeFilter($callback)
	{
		if (($index = array_search('Dwoo_Filter_'.$callback, $this->filters, true)) !== false) {
			unset($this->filters[$index]);
		} elseif (($index = array_search($callback, $this->filters, true)) !== false) {
			unset($this->filters[$index]);
		} else	{
			$class = 'Dwoo_Filter_' . $callback;
			foreach ($this->filters as $index=>$filter) {
				if (is_array($filter) && $filter[0] instanceof $class) {
					unset($this->filters[$index]);
					break;
				}
			}
		}
	}