Return's the tax class ID for the passed tax class name.

@param string $taxClassName The tax class name to return the ID for

@return integer The tax class ID
@throws \Exception Is thrown, if the tax class with the requested name is not available
766566
public function getTaxClassIdByTaxClassName($taxClassName)
    {

        // query whether or not, the requested tax class is available
        if (isset($this->taxClasses[$taxClassName])) {
            return (integer) $this->taxClasses[$taxClassName][MemberNames::CLASS_ID];
        }

        // throw an exception, if not
        throw new \Exception(
            $this->appendExceptionSuffix(
                sprintf('Found invalid tax class name %s', $taxClassName)
            )
        );
    }
222269
public function getClass($id)
    {
        return isset($this->classes[$id]) ? $this->classes[$id] : null;
    }
1296869
public function get($className)
    {
        if (!$this->has($className)) {
            throw new Exception('Repository ' . $className . ' not found');
        }
        return $this->pool[$className];
    }
1332140
function &findClass($className)
    {
        $return = NULL;
        if (isset($this->_classes[$className])) {
            $return =& $this->_classes[$className];
        }

        return $return;
    }
229628
public function getTableClass($className) {
        $tableClass= null;
        if ($className= $this->loadClass($className)) {
            if (isset ($this->map[$className]['table'])) {
                $tableClass= $className;
            }
            if (!$tableClass && $ancestry= $this->getAncestry($className, false)) {
                foreach ($ancestry as $ancestor) {
                    if (isset ($this->map[$ancestor]['table'])) {
                        $tableClass= $ancestor;
                        break;
                    }
                }
            }
        }
        if ($tableClass) {
            if ($this->getDebug() === true) {
                $this->log(xPDO::LOG_LEVEL_DEBUG, 'Returning table class: ' . $tableClass . ' for class: ' . $className);
            }
        } else {
            $this->log(xPDO::LOG_LEVEL_ERROR, 'Could not get table class for class: ' . $className);
        }
        return $tableClass;
    }
1232734
public function getPreconditionByClassName($className)
    {
        if (!class_exists($className, true)) {
            throw new Exception(sprintf('The precondition class %s does not exist', $className));
        }
        $result = $this->app->make($className);
        if (!$result instanceof PreconditionInterface) {
            throw new Exception(sprintf('The class %1$s should implement the interface %2$s', $className, PreconditionInterface::class));
        }

        return $result;
    }
1093953
public function findByEntityClassname($classname)
    {
        //get all the business entities
        $businessEntities = $this->getBusinessEntities();

        //the result
        $businessEntity = null;

        //parse the business entities
        foreach ($businessEntities as $tempBusinessEntity) {
            //look for the same id
            if ($tempBusinessEntity->getClass() === $classname) {
                $businessEntity = $tempBusinessEntity;
                //business entity was found, there is no need to continue
                continue;
            }
        }

        return $businessEntity;
    }
370211
protected static function getInstanceByClassName(string $className, string $fileName)
    {
        if (class_exists($className)) {
            $interface = '\Crossjoin\Browscap\Parser\Sqlite\Adapter\AdapterFactoryInterface';
            $interfaces = class_implements($className);
            if (array_key_exists(ltrim($interface, '\\'), $interfaces)) {
                try {
                    return new $className($fileName);
                } catch (BrowscapException $e) {
                    // Ignore exception, because we just return NULL on failure
                }
            } else {
                throw new UnexpectedValueException(
                    "Class '$className' has to implement the interface '$interface'.",
                    1459000689
                );
            }
        } else {
            throw new UnexpectedValueException("Class '$className' doesn't exist.", 1459000690);
        }

        return null;
    }
917541
public function getClassNameById($classId)
    {
        $className = $this->getClassNameFromShopMap($classId);

        if (empty($className)) {
            $className = $this->getClassNameFromModuleMap($classId);
        }
        return $className;
    }
418483
public static function storageIdByClass($className)
    {
        foreach (self::storageHandlers() as $id => $handler) {
            if ($handler instanceof $className) {
                return $id;
            }
        }
        return null;
    }
1076873
public function getByClassname(string $classname)
    {
        foreach ($this->container as $value) {
            if (is_object($value) && $value instanceof $classname) {
                return $value;
            }
        }

        return null;
    }
349907
public function handlerIdByClassName($className)
    {
        foreach ($this->handlers() as $id => $class) {
            if ($class->className() === $className) {
                return $id;
            }
        }

        throw new Exception("Handler with classname {$className} not found.");
    }
1084969
public function get($class = null)
        {
            $class = $this->getClass($class);

            if (Arrays::exists($class, $this->reflections)) {
                return $this->reflections[$class];
            }

            throw new Exception("Class not found: $class");
        }
59296
public function getEntity($className, $id)
    {
        if (isset($this->entities[$className]) && isset($this->entities[$className][$id])) {
            return $this->entities[$className][$id];
        }

        if (isset($this->stashedEntities[$className]) && isset($this->stashedEntities[$className][$id])) {
            return $this->stashedEntities[$className][$id];
        }

        return null;
    }
503677
public static function generateId($className = '')
	{
		// TODO: on 32bit systems this might generate low precision hashes due to float number usage in the base_convert function
		$timeParts = explode(' ', microtime(false));
		$timeParts[0] = substr($timeParts[0], 2, 3);
		$time = ((int) $timeParts[1] - 1324027985) . $timeParts[0];
		$time = base_convert($time, 10, 36);
		$time = substr($time, -9);
		$time = str_pad($time, 9, '0', STR_PAD_LEFT);

		// Local sequence usage
		$sequence = base_convert(self::$idSequence++, 10, 36);
		$sequence = substr($sequence, -2);
		$sequence = str_pad($sequence, 2, '0', STR_PAD_LEFT);

		$random = sha1(uniqid($className, true));
		$random = base_convert($random, 16, 36);
		$random = substr($random, -9);
		$random = str_pad($random, 9, '0', STR_PAD_LEFT);

		return $time . $sequence . $random;
	}
889375
public function loadClass($className) {
        $classFound = $this->composerClassLoader->loadClass($className);
        if (!$classFound && !$this->caseSensitiveClassLoading) {
            $classFound = $this->composerClassLoader->loadClass(strtolower($className));
        }
        return $classFound;
    }
576396
public function getFieldType($fieldName)
    {
        if (!array_key_exists($fieldName, $this->_fields)) {
            throw new \Exception("Field name \"$fieldName\" not found in document.");
        }

        return $this->_fields[$fieldName]->getType ();
    }