Register base class

@param $class
@param string $pattern
@param float $sort

@return ClassReflection
975886
public function registerBaseClass($class, $pattern = null, $sort = null)
    {
        return $this->_baseClassRegistry->register($class, $pattern, $sort);
    }
37035
public function addRaw(string $pattern): self
    {
        if (substr($pattern, 0, 2)=='./') {
            $pattern = substr($pattern, 2);
        }
        if (!in_array($pattern, $this->raws)) {
            $this->raws[] = $pattern;
        }

        return $this;
    }
617436
public function notName(string $pattern): self
    {
        $filter = new Iterator\FilenameFilterIterator($this->getIterator(), [], [$pattern]);

        return new self(iterator_to_array($filter));
    }
324598
public function register($type, $class, $legacy = false)
	{
		if (!@is_subclass_of($class, $this->default[$type]))
		{
			return false;
		}

		$this->classes[$type] = $class;

		if ($legacy)
		{
			$this->legacy[] = $class;
		}

		return true;
	}
1170207
public static function registerLookup($class, $name = null)
    {
        /* @var $class BaseLookup */
        if (is_null($name)) {
            $name = strtolower($class::$lookupName);
        }
        self::$lookups[$name] = $class;
    }
1212064
public function addClass($class)
    {
        $reflectedclass = Smd\Service::read($this, $class);
        if ( $reflectedclass !== false ) {
            $this->services[] = $reflectedclass;
        }
        return $this;
    }
222638
private function importDefinition($pattern)
    {
        $entityNames = [];

        foreach ($this->findFiles($pattern) as $file) {
            $basename   = basename($file, '.xml');
            $definition = $this->builder->getMeta($basename);

            if (!empty($this->entityDefinitions[$basename])) {
                if ($this->entityDefinitions[$basename]->class == $definition->class) {
                    // Might be an update
                    continue;
                }

                throw new \RuntimeException("Another definition for $basename already exists!");
            }

            $this->entityDefinitions[$basename] = $definition;
            $entityNames[]                      = $basename;
        }

        return $entityNames;
    }
911040
public function setPattern($pattern)
    {
        $this->_pattern = (string) $pattern;
        $status         = @preg_match($this->_pattern, "Test");

        if (false === $status) {
            // require_once 'Zend/Validate/Exception.php';
            throw new Zend_Validate_Exception("Internal error while using the pattern '$this->_pattern'");
        }

        return $this;
    }
82001
public function matchPattern(string $pattern) : Element
    {
        $this->attributes['pattern'] = $pattern;
        return $this->addTest('pattern', function ($value) use ($pattern) {
            return preg_match("@^$pattern$@", trim($value));
        });
    }
299154
public function psubscribe($pattern /* ... */)
    {
        $this->writeRequest(self::PSUBSCRIBE, func_get_args());
        $this->statusFlags |= self::STATUS_PSUBSCRIBED;
    }
333121
public function setRegexp($pattern)
    {
        $regexp = new RegularExpression();
        $regexp->setPattern($pattern);
        $this->_regexps[] = $regexp;
    }
852020
public function registerFormat($format, $class)
    {
        if ( ! class_exists($class)) {
            throw new \InvalidArgumentException("Responder formatter class {$class} not found.");
        }
        if ( ! is_a($class, 'Nathanmac\Utilities\Responder\Formats\FormatInterface', true)) {
            throw new \InvalidArgumentException('Responder formatters must implement the Nathanmac\Utilities\Responder\Formats\FormatInterface interface.');
        }

        $this->supported_formats[$format] = $class;

        return $this;
    }
441468
protected function registerObserver($class)
    {
        $className = is_string($class) ? $class : get_class($class);

        foreach ($this->getObservableEvents() as $event) {
            if (method_exists($class, $event)) {
                static::registerModelEvent($event, $className . '@' . $event);
            }
        }
    }
1019309
public function registerProcessor(string $class, string $processorClass): void
    {
        if (! (new \ReflectionClass($processorClass))->implementsInterface(ProcessorInterface::class)) {
            throw InvalidArgumentException::create(InvalidArgumentException::INVALID_PROCESSOR_INTERFACE_CLASS, $processorClass);
        }

        if (! isset($this->processors[$class])) {
            $this->processors[$class] = $processorClass;
        } elseif (! is_array($this->processors[$class])) {
            $this->processors[$class] = [$this->processors[$class], $processorClass];
        } else {
            $this->processors[$class][] = $processorClass;
        }
    }
533874
public function orderBy(string $column, string $sort = 'desc'): BaseQueryRelateContract
    {
        $this->query->orderBy($column, $sort);

        return $this;
    }
1152677
private function registerCommand($class, $command)
    {
        $this->app->singleton($this->commandPath . $command, function ($app) use ($class) {
            return $app[$class];
        });

        $this->commands($this->commandPath . $command);
    }
452756
public function registerTrait($trait, $pattern = null, $sort = null)
    {
        return $this->_builder->registerTrait($trait, $pattern, $sort);
    }