MetricCallable 

/**
* @brief This class provides access to metrics information for callables.
*/

Inherit from Callable

Primary key: id: int

schema MetricCallable extends Callable {
  @primary id: int
}

MetricCallable::getLocation 

/**
* @brief gets the location for the element.
* @return Location
*/

pub fn getLocation(self: MetricCallable) -> Location;

MetricCallable::getType 

/**
* @brief gets the name of the callable
* @return string 
*/

pub fn getType(self: MetricCallable) -> Type;

MetricCallable::getCallee 

/**
* @brief gets the callee of the callable
* @return Callable 
*/

pub fn getCallee(self: MetricCallable) -> *Callable;

MetricCallable::getBelongedInterface 

/**
* @brief gets the parent of the Callable element.
* @return Interface 
*/

pub fn getBelongedInterface(self: MetricCallable) -> Interface;

MetricCallable::getBody 

/**
* @brief gets the body of the method.
* @return CodeBlock 
*/

pub fn getBody(self: MetricCallable) -> CodeBlock;

MetricCallable::getHalsteadLength 

/**
* @brief The Halstead length of a callable is estimated as the sum of the number of statements and expressions within the callable, plus one for the callable itself.
* @return int 
*/

pub fn getHalsteadLength(self: MetricCallable) -> int;

MetricCallable::getHalsteadVocabulary 

/**
* @brief  The Halstead vocabulary of a callable is estimated as the number of unique Halstead IDs of all statements and expressions within the callable.
* @return int 
*/

pub fn getHalsteadVocabulary(self: MetricCallable) -> int;

MetricCallable::getADependency 

/**
* @brief * Gets a callable on which this callable depends. A callable `m` depends on another callable `n` if there exists a call to `n` from within `m`, taking overriding into account.
* @return Callable 
*/

pub fn getADependency(self: MetricCallable) -> *Callable;

MetricCallable::getCalleeFromAnonymousMethod 

/**
* @brief gets the extra callee from enclosed anonymous method.
* @return callee 
*/

pub fn getCalleeFromAnonymousMethod(self: MetricCallable) -> *Callable;

MetricCallable::getAnnotation 

/**
* @brief gets the annotation of the Callable element.
* @return Annotation 
*/

pub fn getAnnotation(self: MetricCallable) -> *Annotation;

MetricCallable::__all__

Data constraint method.

pub fn __all__(db: JavaDB) -> *MetricCallable;

MetricCallable::getModifier 

/**
* @brief gets the modifier of the callable.
* @return Modifier 
*/

pub fn getModifier(self: MetricCallable) -> *Modifier;

MetricCallable::getPolyCallable 

/**
* @brief gets the polymorphism methods of the method, if any.
* @return Method 
*/

pub fn getPolyCallable(self: MetricCallable) -> *Callable;

MetricCallable::getParameter 

/**
* @brief gets the parameter of the method, if any.
* @return Parameter 
*/

pub fn getParameter(self: MetricCallable) -> *Parameter;

MetricCallable::getAfferentCoupling 

/**
* @brief The afferent coupling of a callable is defined as
* the number of callables that depend on this callable.
*
* This may also be referred to as the "fan-in" or
* "incoming dependencies" of a callable.
* @return int 
*/

pub fn getAfferentCoupling(self: MetricCallable) -> int;

MetricCallable::getAnAncestorCaller 

/**
* @brief gets an ancestor caller of the callable, if any
* @return Callable 
*/

pub fn getAnAncestorCaller(self: MetricCallable) -> *Callable;

MetricCallable::getSignature 

/**
* @brief gets the name of the callable
* @return string 
*/

pub fn getSignature(self: MetricCallable) -> string;

MetricCallable::getEnclosedAnonymousMethod 

/**
* @brief gets the anonymous method enclosed by it.
* @return AnonymousMethod 
*/

pub fn getEnclosedAnonymousMethod(self: MetricCallable) -> *AnonymousMethod;

MetricCallable::getCyclomaticComplexity 

/**
* @brief The cyclomatic complexity of a callable is defined as the number
* of branching statements (`if`, `while`, `do`, `for`, `switch`, `case`, `catch`)
* plus the number of branching expressions (`?`, `&&` and `||`)
* plus one.
* @return int 
*/

pub fn getCyclomaticComplexity(self: MetricCallable) -> int;

MetricCallable::getCaller 

/**
* @brief gets the caller of the callable
* @return Callable 
*/

pub fn getCaller(self: MetricCallable) -> *Callable;

MetricCallable::getEfferentCoupling 

/**
* @brief * The efferent coupling of a callable is defined as
* the number of callables on which this callable depends.
*
* This may also be referred to as the "fan-out" or
* "outgoing dependencies" of a callable.
* @return int 
*/

pub fn getEfferentCoupling(self: MetricCallable) -> int;

MetricCallable::getAnAncestor 

/**
* @brief gets an ancestor of the element.
* @return ElementParent 
*/

pub fn getAnAncestor(self: MetricCallable) -> *ElementParent;

MetricCallable::getAnAncestorCallee 

/**
* @brief gets an ancestor callee of the callable, if any
* @return Callable 
*/

pub fn getAnAncestorCallee(self: MetricCallable) -> *Callable;

MetricCallable::getReturnType 

/**
* @brief gets the type for the element.
* @return Type
*/

pub fn getReturnType(self: MetricCallable) -> Type;

MetricCallable::getBelongedClass 

/**
* @brief gets the parent of the Callable element.
* @return ClassOrInterface 
*/

pub fn getBelongedClass(self: MetricCallable) -> ClassOrInterface;

MetricCallable::getSize 

/**
* @brief gets the size for the element.
* @return NumberOfLines
*/

pub fn getSize(self: MetricCallable) -> NumberOfLines;

MetricCallable::getName 

/**
* @brief gets the name of the callable
* @return string 
*/

pub fn getName(self: MetricCallable) -> string;