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;