pycodeanalyzer.core.abstraction.objects

Object abstraction.

This modules containes all the abstraction for code object manipulated by pycodeanalyzer

Summary

Classes:

`AbstractClass`	Class abstraction
`AbstractClassClassifier`	Classifier for class objects
`AbstractEnum`	Enum abstraction
`AbstractFunction`	Function abstraction
`AbstractObject`	Base of all abstraction
`AbstractObjectLanguage`	Language of the code source

Functions:

`compareAbstractObject`	Comparison operator to sort AbstractObject and subclasses
`platformIndependantPathHash`

Diagrams

AbstractClass

classDiagram class AbstractClass { <<Class>> + str namespace + str type + List<Tuple<str,str,str>> members + List<Tuple<str,str,List<Tuple<str,str>>,str>> methodes + List<Tuple<str,str,str>> parents + List~str~ linkedGenericTypes + List~AbstractClassClassifier~ classifiers +Constructor(str name, str namespace, str origin) None +addGenericType(str genType) None +addMember(str type, str name, str visibility) None +hasMember(str name) bool +addMethod(str returnType, str name, List<Tuple<str,str>> parameters, str visibility) None +addParent(str completetype, str name, str visibility) None +addClassifier(AbstractClassClassifier classifier) None +getMainClassifier() str +getLinkedTypes() List~str~ -isPotentialClassName(str type) bool -getDependanceFromType(str type) List~str~ -splitTypes(Any decl) List~str~ +getFullName() str -cleanLanguageArtifacts(str type) str -removeNonObjectTypes(List~str~ typeList) List~str~ +isParent(AbstractClass klass) bool +print() None } class AbstractObject { <<Class>> + str name + str type + str origin + List~str~ usingNS + AbstractObjectLanguage objectLanguage + List~str~ linkedGenericTypes +Constructor(str name, str origin) None +addUsingNamespace(str namespace) None } link AbstractObject "class££pycodeanalyzer::core::abstraction::objects::AbstractObject" class AbstractClassClassifier { <<Enum>> + NoClassifier + External + Generic + Message + Data } link AbstractClassClassifier "enum££pycodeanalyzer::core::abstraction::objects::AbstractClassClassifier" AbstractClass --|> AbstractObject AbstractClass ..> AbstractClassClassifier
AbstractClass class diagram

AbstractClassClassifier

classDiagram class AbstractClassClassifier { <<Enum>> + NoClassifier + External + Generic + Message + Data }
AbstractClassClassifier class diagram

AbstractEnum

classDiagram class AbstractEnum { <<Class>> + str namespace + str type + List~str~ values +Constructor(str name, str namespace, str origin, List~str~ values) None +getFullName() str +print() None } class AbstractObject { <<Class>> + str name + str type + str origin + List~str~ usingNS + AbstractObjectLanguage objectLanguage + List~str~ linkedGenericTypes +Constructor(str name, str origin) None +addUsingNamespace(str namespace) None } link AbstractObject "class££pycodeanalyzer::core::abstraction::objects::AbstractObject" AbstractEnum --|> AbstractObject
AbstractEnum class diagram

AbstractFunction

classDiagram class AbstractFunction { <<Class>> + str namespace + str type + str returnType + List<Tuple<str,str>> parameters + str doxygen + List~str~ linkedGenericTypes +Constructor(str name, str origin, str returnType, List<Tuple<str,str>> parameters, str namespace, str doxygen) None +addGenericType(str genType) None +print() None +getFullDef() str } class AbstractObject { <<Class>> + str name + str type + str origin + List~str~ usingNS + AbstractObjectLanguage objectLanguage + List~str~ linkedGenericTypes +Constructor(str name, str origin) None +addUsingNamespace(str namespace) None } link AbstractObject "class££pycodeanalyzer::core::abstraction::objects::AbstractObject" AbstractFunction --|> AbstractObject
AbstractFunction class diagram

AbstractObject

classDiagram class AbstractObject { <<Class>> + str name + str type + str origin + List~str~ usingNS + AbstractObjectLanguage objectLanguage + List~str~ linkedGenericTypes +Constructor(str name, str origin) None +addUsingNamespace(str namespace) None } class AbstractObjectLanguage { <<Enum>> + Unknown + CPP + Python + Java + Kotlin } link AbstractObjectLanguage "enum££pycodeanalyzer::core::abstraction::objects::AbstractObjectLanguage" AbstractObject ..> AbstractObjectLanguage
AbstractObject class diagram

AbstractObjectLanguage

classDiagram class AbstractObjectLanguage { <<Enum>> + Unknown + CPP + Python + Java + Kotlin }
AbstractObjectLanguage class diagram

Reference

class pycodeanalyzer.core.abstraction.objects.AbstractObjectLanguage(value)[source]

Bases: enum.IntEnum

Language of the code source

Enum representing supported languages

Unknown = 0

CPP = 1

Python = 2

Java = 3

Kotlin = 4

class pycodeanalyzer.core.abstraction.objects.AbstractObject(name: str, origin: str)[source]

Bases: object

Base of all abstraction

addUsingNamespace(namespace: str) → None[source]

class pycodeanalyzer.core.abstraction.objects.AbstractEnum(name: str, namespace: str, origin: str, values: List[str])[source]

Bases: pycodeanalyzer.core.abstraction.objects.AbstractObject

Enum abstraction

getFullName() → str[source]

print() → None[source]

class pycodeanalyzer.core.abstraction.objects.AbstractFunction(name: str, origin: str, returnType: str, parameters: List[Tuple[str, str]], namespace: str, doxygen: str)[source]

Bases: pycodeanalyzer.core.abstraction.objects.AbstractObject

Function abstraction

addGenericType(genType: str) → None[source]

print() → None[source]

getFullDef() → str[source]

class pycodeanalyzer.core.abstraction.objects.AbstractClassClassifier(value)[source]

Bases: enum.IntEnum

Classifier for class objects

Enum representing additionnal data

NoClassifier = 0

External = 1

Generic = 2

Message = 3

Data = 4

class pycodeanalyzer.core.abstraction.objects.AbstractClass(name: str, namespace: str, origin: str)[source]

Bases: pycodeanalyzer.core.abstraction.objects.AbstractObject

Class abstraction

NonObjectTypes: Dict[pycodeanalyzer.core.abstraction.objects.AbstractObjectLanguage, List[str]] = {AbstractObjectLanguage.Unknown: [], AbstractObjectLanguage.CPP: ['void', 'bool', 'unsigned', 'char', 'unsigned char', 'short', 'unsigned short', 'int', 'unsigned int', 'long', 'unsigned long', 'long long', 'unsigned long long', 'float', 'double', 'int8_t', 'int16_t', 'int32_t', 'int64_t', 'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32', 'uint64', 'size_t'], AbstractObjectLanguage.Python: ['Any', 'None', 'List', 'Tuple', 'Dict', 'str', 'float', 'int', 'long', 'bool'], AbstractObjectLanguage.Java: ['void', 'byte', 'int', 'short', 'long', 'float', 'double', 'boolean', 'char', 'String', 'Object', 'Integer', 'Short', 'Long', 'Float', 'Double', 'Boolean', 'Byte', 'Char', 'Void'], AbstractObjectLanguage.Kotlin: ['KotlinAuto', 'Unit', 'Byte', 'Short', 'Int', 'Long', 'Float', 'Double', 'Boolean', 'Char', 'String', 'Array', 'Object', 'Void']}

addGenericType(genType: str) → None[source]

addMember(type: str, name: str, visibility: str) → None[source]

hasMember(name: str) → bool[source]

addMethod(returnType: str, name: str, parameters: List[Tuple[str, str]], visibility: str) → None[source]

addParent(completetype: str, name: str, visibility: str) → None[source]

addClassifier(classifier: pycodeanalyzer.core.abstraction.objects.AbstractClassClassifier) → None[source]

getMainClassifier() → str[source]

getLinkedTypes() → List[str][source]

getFullName() → str[source]

isParent(klass: pycodeanalyzer.core.abstraction.objects.AbstractClass) → bool[source]

print() → None[source]

pycodeanalyzer.core.abstraction.objects.platformIndependantPathHash(path: str) → str[source]

pycodeanalyzer.core.abstraction.objects.compareAbstractObject(obj: pycodeanalyzer.core.abstraction.objects.AbstractObject) → Tuple[str, str, str][source]

Comparison operator to sort AbstractObject and subclasses

This allow to sort by type, origin and name

This file was automatically generated using better_apidoc.