மாடலிங் மொழி கோர்

முக்கிய மாடலிங் மொழி வேறு எந்த மொழிக்கும் அடிப்படையாகும்.

Base வகுப்பு அனைத்து gaphor டொமைன் வகுப்புகளுக்கும் மூலக்கூறாகச் செயல்படுகிறது. Diagram மற்றும் Presentation ஆகியவை ஒரு வரைபடத்தில் நீங்கள் காணும் அனைத்திற்கும் அடிப்படையாக அமைகின்றன.

GAPHOR இல் உள்ள அனைத்து தரவு மாதிரிகள் உண்மையான GAPHOR மாதிரி கோப்புகளிலிருந்து உருவாக்கப்படுகின்றன. கஃபரின் உள் மாதிரியின் நல்ல வரைபடங்களை உங்களுக்கு வழங்க இது எங்களை அனுமதிக்கிறது.

விளக்கக்காட்சி வகுப்புகளுடன் முக்கிய மாதிரி

Base வகுப்பு

Base வகுப்பு நிகழ்வு அறிவிப்பை வழங்குகிறது மற்றும் மாதிரி களஞ்சியத்துடன் ஒருங்கிணைக்கிறது (உள்நாட்டில் ElementFactory என அழைக்கப்படுகிறது). ஒரு மாதிரியில் உள்ள அனைத்து வகுப்புகளும் இந்த வகுப்பிலிருந்து பெறப்பட வேண்டும். ஒரு மாதிரி ஒரு உறுப்புக்கான அடிப்படை வகுப்பைக் காட்டவில்லை என்றால், அது Base இலிருந்து பெறப்படும். இரு திசை உறவுகளும் சாத்தியமாகும், அதே போல் பெறப்பட்ட உறவுகளும் சாத்தியமாகும்.

மாதிரியை களஞ்சியத்துடனும் நிகழ்வு கையாளும் வழிமுறைகளுடனும் இணைக்க RepositoryProtocol, மற்றும் EventWatcherProtocol நெறிமுறைகள் முக்கியமானவை.

வகுப்பு Base என்பது காஃபரின் தரவு மாதிரியின் மையமாகும்.

class gaphor.core.modeling.Base(id: str | None = None, model: RepositoryProtocol | None = None)

அனைத்து மாதிரி தரவு வகுப்புகளுக்கான அடிப்படை வகுப்பு.

property id: str

ஒரு ஐடி (படிக்க மட்டும்), மாதிரியில் தனித்துவமானது.

property model: RepositoryProtocol

மாடல் அமைக்கப்படாதபோது, சொந்த மாதிரி TypeError ஐ எழுப்புகிறது.

unlink() → None

உறுப்பை இணைக்கவும்.

அனைத்து கூறுகளின் குறிப்புகளும் அழிக்கப்படுகின்றன. கலப்பு சங்கங்களுக்கு, தொடர்புடைய கூறுகளும் இணைக்கப்படவில்லை.

மறுநிகழ்வு சிக்கல்களைத் தவிர்ப்பதற்காக இந்த உறுப்பின் பண்புகளை அவிழ்த்துவிடும்போது அன்லிங்க் பூட்டு பெறப்படுகிறது.

நிகழ்வு கையாளுதல்

handle(event: object) → None

உள்வரும் நிகழ்வுகளை பிரச்சாரம் செய்யுங்கள்.

உறுப்பு உருவாக்கப்பட்டிருந்தால் மட்டுமே இது செயல்படும் ElementFactory

watcher(default_handler: Callable[[ElementUpdated], None] | None = None) → EventWatcherProtocol

இந்த உறுப்புக்கு புதிய கண்காணிப்பாளரை உருவாக்கவும்.

self உடன் தொடர்புடைய ஒரு சொத்து மாற்றப்பட்டால் சமிக்ஞை செய்ய பார்வையாளர்கள் வசதியான வழியை வழங்குகிறார்கள்.

ஒரு பார்வையாளரைப் பயன்படுத்த, உறுப்பு ஒழுங்காக கம்பி மூலம் உருவாக்கப்பட வேண்டும் ElementFactory`.

இந்த எடுத்துக்காட்டு முற்றிலும் விளக்கமானது:

>>> element = Base()
>>> watcher = element.watcher(default_handler=print)
>>> watcher.watch("note")  # Watch for changed on element.note

ஏற்றுதல் மற்றும் சேமித்தல்

load(name: str, value: str | bool | int | Base | collection[Base]) → None

பெயரில் மதிப்பு ஏற்றுகிறது.

எல்லா கூறுகளும் ஏற்றப்பட்ட பிறகு, போச்ட் லோட் () என்று அழைக்கப்பட வேண்டும் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.

postload() → None

முரண்பாடுகள் மற்றும் முனைகளை சரிசெய்யவும்.

அனைத்து கூறுகளும் ஏற்றப்பட்ட பிறகு இது இயக்கப்படுகிறது.

save(save_func: Callable[[str, str | bool | int | Base | collection[Base]], None]) → None

save_func(name, value) என்று அழைப்பதன் மூலம் மாநிலத்தை சேமிக்கவும்.

OCL- பாணி முறைகள்

isKindOf(class_: type[Base]) → bool

வருமானம் True பொருள் class_ இன் உதாரணமாக இருந்தால்.

isTypeOf(other: Base) → bool

வருமானம் True பொருள் other அதே வகையாக இருந்தால்.

Presentation வகுப்பு

class gaphor.core.modeling.Presentation(diagram: Diagram, id: Id | None = None)

ஒரு சிறப்பு வகை Base இது ஒரு Diagram இல் காட்டப்படலாம்.

விளக்கக்காட்சி நிகழ்வுகள் வரைபடங்களுக்கு மட்டுமே சொந்தமாக இருக்க முடியும்.

Presentation இன் துணை வகைகள் gaphas.item.Item நெறிமுறை.

request_update() → None

புதுப்பிப்புக்கு இந்த விளக்கக்காட்சி பொருளைக் குறிக்கவும்.

புதுப்பிப்புகள் வரைபடங்களால் திட்டமிடப்படுகின்றன.

watch(path: str, handler: Callable[[ElementUpdated], None] | None = None) → Self

self உடன் தொடங்கும் உறுப்புகளின் ஒரு குறிப்பிட்ட பாதையைப் பாருங்கள்.

கையாளுதல் விருப்பமானது மற்றும் இயல்புநிலை ஒரு எளிய request_update.

கட்டமைப்பாளரில் கடிகாரங்கள் அமைக்கப்பட வேண்டும், எனவே அவை ஒரு சாட்டில் பதிவு செய்யப்பட்டு பதிவு செய்யப்படாது.

self.watch("subject.name")

இந்த இடைமுகம் சரளமாக உள்ளது: self தருகிறது.

change_parent(new_parent: Presentation | None) → None

பெற்றோரை மாற்றி, உருப்படியின் மேட்ரிக்சைப் புதுப்பிக்கவும், எனவே உருப்படி பார்வைக்கு ஒரே இடத்தில் இருக்கும்.

Diagram வகுப்பு

class gaphor.core.modeling.Diagram(id: str | None = None, model: RepositoryProtocol | None = None)

வரைபடங்களில் இருக்கலாம் Presentation கூறுகள்.

வரைபடங்கள் சொந்தமாக இருக்க வேண்டும் என்றால், மாடலிங் மொழி (எ.கா. யுஎம்எல்) Diagram துணைப்பிரிவு செய்து உரிமையாளர் உறவுகள் மற்றும் விதிகளைச் சேர்க்க வேண்டும்.

create(type_: type[P], parent: Presentation | None = None, subject: Base | None = None) → P

வரைபடத்தில் புதிய வரைபட உருப்படியை உருவாக்கவும்.

இது ஒரு தனித்துவமான ஐடியுடன் உருவாக்கப்பட்டது, மேலும் இது வரைபடத்தின் ரூட் உருப்படியுடன் இணைக்கப்பட்டுள்ளது. வகை அளவுரு உருவாக்க வேண்டிய உறுப்பு வகுப்பு. புதிய உறுப்பு ஒரு விருப்ப பெற்றோர் மற்றும் பொருள் ஆகியவற்றைக் கொண்டுள்ளது.

lookup(id: str) → Presentation | None

ஐடி மூலம் விளக்கக்காட்சி உருப்படியைக் கண்டறியவும்.

இந்த வரைபடத்தில் ஒரு விளக்கக்காட்சியை வழங்குகிறது அல்லது None திரும்புகிறது.

select(expression: Callable[[Presentation], bool]) → Iterator[Presentation]

select(expression: type[P]) → Iterator[P]

select(expression: None) → Iterator[Presentation]

வெளிப்பாட்டுடன் பொருந்தக்கூடிய அனைத்து கேன்வாச் உருப்படிகளின் மறுசீரமைப்பாளரைத் தரவும்.

request_update(item: Item) → None

புதுப்பிக்க ஒரு உருப்படியை திட்டமிடுங்கள்.

இந்த கட்டத்தில் எந்த புதுப்பிப்பும் செய்யப்படவில்லை, இது புதுப்பிக்கப்பட்ட உருப்படிகளின் தொகுப்பில் மட்டுமே சேர்க்கப்பட்டுள்ளது.

இந்த முறை gaphas.model.Model நெறிமுறையின் ஒரு பகுதியாகும்.

update(dirty_items: Collection[Presentation] = ()) → None

வரைபடத்தைப் புதுப்பிக்கவும்.

புதுப்பிப்பைக் கோரிய அனைத்து உருப்படிகளும் request_update() இப்போது புதுப்பிப்புகள். ஒரு உருப்படிக்கு update(context: UpdateContext) முறை இருந்தால், அது செயல்படுத்தப்படுகிறது. தடைகள் தீர்க்கப்படுகின்றன.

நெறிமுறைகள்

class gaphor.core.modeling.base.RepositoryProtocol(*args, **kwargs)

create(type: type[T]) → T

களஞ்சியத்தில் ஒரு புதிய உறுப்பை உருவாக்கவும்.

select(self, expression: Callable[[Base], bool]) → Iterator[Base]

expression நிறைவேற்றும் களஞ்சியத்திலிருந்து கூறுகளைத் தேர்ந்தெடுக்கவும்.

select(self, type_: type[T]) → Iterator[T]

type_ வகையின் களஞ்சியத்திலிருந்து அனைத்து கூறுகளையும் தேர்ந்தெடுக்கவும்.

select(self, expression: None) → Iterator[Base]

களஞ்சியத்திலிருந்து அனைத்து கூறுகளையும் தேர்ந்தெடுக்கவும்.

lookup(id: str) → Base | None

களஞ்சியத்திலிருந்து ஐடி மூலம் ஒரு உறுப்பைப் பெறுங்கள்.

வருமானம் None அத்தகைய உறுப்பு இல்லை என்றால்.

class gaphor.core.modeling.base.EventWatcherProtocol(*args, **kwargs)

watch(path: str, handler: Callable[[ElementUpdated], None] | None = None) → EventWatcherProtocol

ஒரு குறிப்பிட்ட பாதைக்கு ஒரு கடிகாரத்தைச் சேர்க்கவும். பாதை வாட்சர் பொருளை உருவாக்கிய உறுப்புடன் தொடர்புடையது.

self வருமானம், எனவே கண்காணிப்பு செயல்பாடுகளை சங்கிலியால் பிணைக்க முடியும்.

unsubscribe_all() → None

பார்க்கும் அனைத்து பாதைகளையும் விடுவிக்க, பார்வையாளர் அகற்றப்படுவதற்கு முன்பு அழைக்கப்பட வேண்டும்.