Returns the exception name, followed by the code (if present).

@return string
@since 2.0.11
518675
protected function getExceptionName(): string
    {
        $exception = $this->getException();

        if ($exception instanceof Exception) {
            $name = $exception->getName();
        } else {
            $name = $this->getDefaultName();
        }

        if ($code = $this->getExceptionCode()) {
            $name .= " (#$code)";
        }

        return $name;
    }
995362
public function getNamespaceName()
    {
        $caller = get_called_class();
        $parts  = explode('\\', $caller);
        array_pop($parts);
        
        return join('\\', $parts);
    }
416644
public function getReceptionCodes()
    {
        $rcLib = $this->util->getReceptionCodeLibrary();

        if ($this->unDelete) {
            return $rcLib->getTrackRestoreCodes();
        }

        return $rcLib->getTrackDeletionCodes();
    }
886309
public function getErrorsAsText(): string
    {
        $result = '';
        $fieldCounter = 0;
        $fields = $this->getErrors();

        foreach ($fields as $fieldName => $fieldErrors) {
            $fieldCounter++;
            $result .= "$fieldCounter) $fieldName\n";

            foreach ($fieldErrors as $error) {
                $result .= "   - $error\n";
            }
        }

        return $result;
    }
1269674
public static function getSequenceName()
    {
        $cls = get_called_class();
        if (!array_key_exists($cls, self::$_sequence)) {
            return null;
        }
        return self::$_sequence[$cls];
    }
1298311
public function getErrorMessage( bool $appendPreviousByNewline = false ) : string
   {

      // Getting a optional previous exception
      $prev = $this->getPrevious();

      if ( \is_null( $prev ) )
      {
         // If no previous exception is used
         return \sprintf(
            '%s(%d): %s',
            static::GetCodeName( $this->getCode() ),
            $this->getCode(),
            $this->getMessage()
         );
      }

      // Define the separator between current and previous exception.
      $separator = $appendPreviousByNewline ? "\n" : ' ';

      if ( ( $prev instanceof BelugaError ) )
      {
         return \sprintf(
            '%s(%d): %s%s%s',
            static::GetCodeName( $this->getCode() ),
            $this->getCode(),
            $this->getMessage(),
            $separator,
            $prev->getErrorMessage( $appendPreviousByNewline )
         );
      }

      return \sprintf(
         '%s(%d): %s%s%s',
         static::GetCodeName( $this->getCode() ),
         $this->getCode(),
         $this->getMessage(),
         $separator,
         $prev->getMessage()
      );

   }
893799
protected function getExceptionCode()
    {
        $exception = $this->getException();

        $code = $exception->getCode();
        if ($exception instanceof \ErrorException) {
            // ErrorExceptions wrap the php-error types within the 'severity' property
            $code = Misc::translateErrorCode($exception->getSeverity());
        }

        return (string) $code;
    }
1356981
public static function GetName () {
		$class_name = static::class;
		if (!isset(static::$_nameList[$class_name])) {
			if (defined($class_name.'::NAME')) {
				$name = $class_name::NAME;
			} else {
				preg_match("/^(.+)Model$/", str_replace("\\", '/', $class_name), $matches);
				$name = basename($matches[1]);
				if (static::$_useSnakeCase) {
					$name = Strings::ToSnakeCase($name);
				}
			}
			static::$_nameList[$class_name] = $name;
		}
		return static::$_nameList[$class_name];
	}
990253
public function getExceptionsMap()
    {
        if(empty($this->exceptionsMap)) {
            $fileExtToPos = array_flip($this->getPosFileMaps());
            
            foreach($this->getExceptionFileNames() as $fileName )
            {
                $pos = $fileExtToPos[substr($fileName, 0, -4)];
                $fh = fopen($this->getDir().$fileName,'r');
                if(!$fh) {
                    throw new RuntimeException("wordnet file missing {$fileName}");
                }                
                                
                while($line = fgets($fh)) 
                {
                    if($line[0] === ' ') {
                        continue;
                    }
                    $this->exceptionsMap[] = $this->getExceptionMapFromString(trim($line), $pos);

                }               
                fclose($fh);
            } 
        }
        return $this->exceptionsMap;
    }
657735
final public function getName(): string
    {
        try {
            $reflexionConstant = new ReflectionClassConstant($this, 'NAME');
            $this->name        = $reflexionConstant->getValue();
        }
        catch (Exception $e) {
        }

        return $this->name;
    }
684246
public String getName() {
      return (method.getClassModel().getMethod(method.getName(), method.getDescriptor()).getClassModel().getClassWeAreModelling()
            .getName().replace('.', '_')
            + "__" + method.getName());
   }
656056
public function getName() {
		if ($this->_name === null) {
			$name = get_class($this);
			$pos = strrpos($name, '\\');
			if ($pos !== false) {
				$name = substr($name, $pos + 1);
			}
			if (preg_match('/^Twig([A-Za-z]+)Extension$/', $name, $matches)) {
				$name = $matches[1];
			}
			$this->_name = strtolower(preg_replace('/([a-z])([A-Z])/', '$1_$2', $name));
		}
		return $this->_name;
	}
1029835
private function getOnceVarName()
    {
        $name = (string) $this->getRequiredParameter('name');
        $varName = preg_replace('/[^a-zA-Z0-9_]+/i', '', $name);
        if (empty($varName))
            throw new Exception('variable name [' . $name . '] is invalid');

        return $varName;
    }
726445
public function getSourceCodePath()
    {
        if ($this->path === null) {
            $path = [];
            $current = $this;
            while ($current && !$current instanceof FileDescriptor) {
                $parent = $current->getContaining();
                if (!$parent) {
                    throw new \Exception("parent cannot be null");
                }
                array_unshift($path, $current->getIndex());
                // field number in definition:descriptor.proto
                $name = $this->getClassShortName($current);
                $pname = $this->getClassShortName($parent);
                if (isset(self::$pathMap[$name])) {
                    if (is_int(self::$pathMap[$name])) {
                        $fieldNumber = self::$pathMap[$name];
                    } else {
                        if (isset(self::$pathMap[$name][$pname])) {
                            $fieldNumber = self::$pathMap[$name][$pname];
                        } else {
                            throw new \Exception("unimplemented situation $name $pname");
                        }
                    }
                } else {
                    throw new \Exception("unimplemented situation $name $pname");
                }
                array_unshift($path, $fieldNumber);
                $current = $parent;
            }
            $this->path = $path;
        } else {
            $path = $this->path;
        }
        return $path;
    }
184761
protected static function getClassname()
    {
        $className = explode('\\', get_called_class());
        $className = array_pop($className);

        return str_replace('_', '-', strtolower($className));
    }
1223178
public function getOrganizationCode()
    {
        if (! $this->_orgCode) {
            $this->_orgCode = $this->currentOrganization->getCode();
            if (! $this->_orgCode) {
                $this->_orgCode = \MUtil_File::cleanupName($this->currentOrganization->getName());
            }

        }

        return $this->_orgCode;
    }
819664
protected function format_exception( Exception $exception ) {
		$string = get_class( $exception );

		if ( ! empty( $exception->getMessage() ) ) {
			$string .= " : {$exception->getMessage()}";
		}

		if ( ! empty( $exception->getCode() ) ) {
			$string .= " (#{$exception->getCode()})";
		}

		return $string;
	}