gdbus-codegen - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

gdbus-codegen - ഡി-ബസ് കോഡും ഡോക്യുമെന്റേഷൻ ജനറേറ്ററും

സിനോപ്സിസ്

gdbus-codegen [-h, --സഹായിക്കൂ] [--ഇന്റർഫേസ്-പ്രിഫിക്സ് org.project.Prefix]
[--ജനറേറ്റ്-സി-കോഡ് വസ്ത്രങ്ങൾ] [--സി-നാംസ്പേസ് നിങ്ങളുടെ പദ്ധതി]
[--c-genrate-object-manager] [--ജനറേറ്റ്-ഡോക്ബുക്ക് വസ്ത്രങ്ങൾ]
[--xml-files FILE] [--വിശദീകരണം ELEMENT KEY , VALUE-]... ഫയൽ [ഫയൽ...]

വിവരണം

gdbus-codegen ഒന്നോ അതിലധികമോ ഡി-ബസിന്റെ കോഡ് കൂടാതെ/അല്ലെങ്കിൽ ഡോക്യുമെന്റേഷൻ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു
ഇന്റർഫേസുകൾ. ഉപകരണം വായിക്കുന്നു ഡി-ബസ് ബോധം എക്സ്എംഎൽ[1] ഫയലുകൾ നിർമ്മിക്കുകയും ഔട്ട്‌പുട്ട് ഫയലുകൾ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.
ഉപകരണം നിലവിൽ C കോഡ് സൃഷ്ടിക്കുന്നതിനെ പിന്തുണയ്ക്കുന്നു (വഴി --ജനറേറ്റ്-സി-കോഡ്) കൂടാതെ ഡോക്ബുക്ക് XML (വഴി
--ജനറേറ്റ്-ഡോക്ബുക്ക്).

ജനറേറ്റിംഗ് C കോഡ്

സി കോഡ് സൃഷ്ടിക്കുമ്പോൾ, ഓരോ ഡി-ബസ് ഇന്റർഫേസിനും ഒരു #GInterface-derived തരം ജനറേറ്റുചെയ്യുന്നു.
കൂടാതെ, സൃഷ്ടിച്ച എല്ലാ തരത്തിനും, ഫൂബാർ, രണ്ട് കോൺക്രീറ്റ് തൽക്ഷണ തരങ്ങൾ,
FooBarProxy ഒപ്പം FooBarSkeleton, പറഞ്ഞ ഇന്റർഫേസും നടപ്പിലാക്കുന്നു. മുൻ
#GDBusProxy-ൽ നിന്ന് ഉരുത്തിരിഞ്ഞത്, ക്ലയന്റ് വശത്ത് ഉപയോഗിക്കുന്നതിന് ഉദ്ദേശിച്ചുള്ളതാണ്.
#GDBusInterfaceSkeleton തരത്തിൽ നിന്ന് ഉരുത്തിരിഞ്ഞത് a-യിൽ കയറ്റുമതി ചെയ്യുന്നത് എളുപ്പമാക്കുന്നു
#GDBusConnection നേരിട്ട് അല്ലെങ്കിൽ #GDBusObjectManagerServer ഉദാഹരണം വഴി.

ഓരോ ജനറേറ്റഡ് സി തരത്തിന്റെയും പേര് സ്ട്രിപ്പ് ചെയ്ത ഡി-ബസ് ഇന്റർഫേസ് നാമത്തിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതാണ്
കൂടെ നൽകിയിരിക്കുന്ന പ്രിഫിക്സ് --ഇന്റർഫേസ്-പ്രിഫിക്സ് കൂടാതെ ഡോട്ടുകൾ നീക്കംചെയ്ത് പ്രാരംഭ പ്രതീകങ്ങളോടെ
വലിയക്ഷരമാക്കി. ഉദാഹരണത്തിന്, D-Bus ഇന്റർഫേസിന് com.acme.Coyote എന്ന പേര് ഉപയോഗിച്ചിരിക്കുന്നു
ComAcmeCoyote. ഡി-ബസ് ഇന്റർഫേസിനായി org.project.Bar.Frobnicator --ഇന്റർഫേസ്-പ്രിഫിക്സ്
org.project., ഉപയോഗിച്ച പേര് BarFrobnicator എന്നാണ്.

രീതികൾ, സിഗ്നലുകൾ, പ്രോപ്പർട്ടികൾ എന്നിവയ്‌ക്കായി, വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, പേര് സ്ഥിരസ്ഥിതിയായി എന്ന പേരിലേക്ക് മാറുന്നു
രീതി, സിഗ്നൽ അല്ലെങ്കിൽ സ്വത്ത്.

പേരിന്റെ രണ്ട് രൂപങ്ങൾ ഉപയോഗിക്കുന്നു - കാമൽകേസ് ഫോമും ചെറിയ അക്ഷര രൂപവും. ഒട്ടകക്കേസ്
#GType, struct name എന്നിവയ്‌ക്കായി ഫോം ഉപയോഗിക്കുന്നു, അതേസമയം ചെറിയക്ഷര ഫോം ഫംഗ്‌ഷനിൽ ഉപയോഗിക്കുന്നു
പേരുകൾ. കാമൽകേസിൽ നിന്ന് ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്താണ് ലോവർ-കേസ് ഫോം കണക്കാക്കുന്നത്
വാക്കുകളുടെ അതിരുകളിൽ അടിവരയിടൽ (ചില ഹ്യൂറിസ്റ്റിക്സ് ഉപയോഗിച്ച്).

org.gtk.GDBus.C.Name വ്യാഖ്യാനം നൽകിയ മൂല്യം അല്ലെങ്കിൽ --സി-നാംസ്പേസ് ഓപ്ഷൻ
ഒരു അണ്ടർസ്കോർ അടങ്ങിയിരിക്കുന്നു (ചിലപ്പോൾ വിളിക്കുന്നു അഗ്ലി_കേസ്), തുടർന്ന് ഒട്ടക-കേസ് നാമം ഉരുത്തിരിഞ്ഞതാണ്
എല്ലാ അടിവരകളും നീക്കം ചെയ്തുകൊണ്ട്, ലോവർ-കേസ് നാമം ലോവർ-കേസിംഗ് വഴി ഉരുത്തിരിഞ്ഞതാണ്
സ്ട്രിംഗ്. ചുരുക്കെഴുത്തുകൾ ഉപയോഗിക്കുന്ന ചില സാഹചര്യങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്, എങ്കിൽ
net.MyCorp.MyApp.iSCSITarget എന്ന ഇന്റർഫേസിൽ വ്യാഖ്യാനം ഉപയോഗിക്കുന്നു.
iSCSI_Target CamelCase ഫോം iSCSITarget ആണ്, ചെറിയ-കേസ് ഫോം iscsi_target ആണ്.
Eject_The_iPod മൂല്യമുള്ള EjectTheiPod എന്ന രീതിയിലാണ് വ്യാഖ്യാനം ഉപയോഗിക്കുന്നതെങ്കിൽ,
ചെറിയക്ഷരം eject_the_ipod ആണ്.

ജനറേറ്റിംഗ് ഡോക്ബുക്ക് പ്രമാണീകരണം

സൃഷ്ടിച്ച ഓരോ ഡോക്ബുക്ക് XML ഫയലും (കാണുക --ജനറേറ്റ്-ഡോക്ബുക്ക് വിശദാംശങ്ങൾക്കുള്ള ഓപ്ഷൻ) a
റെഫ്എൻട്രി[2] ഡി-ബസ് ഇന്റർഫേസ് വിവരിക്കുന്ന ലേഖനം.

ഓപ്ഷനുകൾ

ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ പിന്തുണയ്ക്കുന്നു:

-h, --സഹായിക്കൂ
സഹായം കാണിച്ച് പുറത്തുകടക്കുക.

--xml-files FILE
ഡി-ബസ് ഇൻട്രോസ്പെക്ഷൻ XML ഫയൽ.

--ഇന്റർഫേസ്-പ്രിഫിക്സ് org.project.Prefix.
ടൈപ്പ് നെയിം കണക്കാക്കുമ്പോൾ എല്ലാ ഡി-ബസ് ഇന്റർഫേസ് നാമങ്ങളിൽ നിന്നും സ്ട്രിപ്പ് ചെയ്യാനുള്ള ഒരു പ്രിഫിക്സ്
സി ബൈൻഡിംഗും ഡോക്ബുക്കും തരം ആട്രിബ്യൂട്ട്[3].

--ജനറേറ്റ്-ഡോക്ബുക്ക് വസ്ത്രങ്ങൾ
ഓരോ ഡി-ബസ് ഇന്റർഫേസിനും ഡോക്ബുക്ക് ഡോക്യുമെന്റേഷൻ സൃഷ്ടിച്ച് അതിൽ ഇടുക
OUTFILES-NAME.xml, ഇവിടെ NAME എന്നത് ഇന്റർഫേസ് നാമത്തിനുള്ള ഒരു പ്ലെയ്‌സ്-ഹോൾഡർ ആണ്, ഉദാ
net.Corp.FooBar തുടങ്ങിയവ.

--ജനറേറ്റ്-സി-കോഡ് വസ്ത്രങ്ങൾ
എല്ലാ ഡി-ബസ് ഇന്റർഫേസുകൾക്കുമായി സി കോഡ് സൃഷ്ടിച്ച് അത് OUTFILES.c, OUTFILES.h എന്നിവയിൽ ഇടുക.

--സി-നാംസ്പേസ് നിങ്ങളുടെ പദ്ധതി
ജനറേറ്റ് ചെയ്ത സി കോഡിനായി ഉപയോഗിക്കേണ്ട നെയിംസ്പേസ്. ഇതുണ്ടാകുമെന്ന് പ്രതീക്ഷിക്കുന്നു ഒട്ടക കേസ്[4] അല്ലെങ്കിൽ
അഗ്ലി_കേസ് (മുകളിൽ കാണുന്ന).

--c-genrate-object-manager
ഈ ഓപ്‌ഷൻ പാസ്സാണെങ്കിൽ, #GDBusObject, #GDBusObjectProxy, അനുയോജ്യമാണ്.
#GDBusObjectSkeleton ഉം #GDBusObjectManagerClient ഉപവിഭാഗങ്ങളും സൃഷ്ടിക്കപ്പെടുന്നു.

--വിശദീകരണം ELEMENT KEY , VALUE-
നൽകിയിരിക്കുന്ന XML ഫയലുകളിലേക്ക് D-Bus വ്യാഖ്യാനങ്ങൾ കുത്തിവയ്ക്കാൻ ഉപയോഗിക്കുന്നു. ഇത് ഉപയോഗിച്ച് ഉപയോഗിക്കാം
ഇനിപ്പറയുന്ന രീതിയിൽ ഇന്റർഫേസുകൾ, രീതികൾ, സിഗ്നലുകൾ, പ്രോപ്പർട്ടികൾ, ആർഗ്യുമെന്റുകൾ:

gdbus-codegen --c-namespace MyApp
--generate-c-code myapp-generated
--വിവരണം "org.project.InterfaceName"
org.gtk.GDBus.C.Name MyFrobnicator
--വിവരണം "org.project.InterfaceName:Property"
ബാർ ബാറ്റ്
--വിവരണം "org.project.InterfaceName.Method()"
org.freedesktop.DBus.ഒഴിവാക്കിയത് ശരിയാണ്
--വിവരണം "org.project.InterfaceName.Method()[arg_name]"
പാമ്പ് ചീറ്റി
--annotate "org.project.InterfaceName::Signal"
പൂച്ച മ്യാവൂ
--annotate "org.project.InterfaceName::Signal[arg_name]"
നായ വഫ്ഫ്
myapp-dbus-interfaces.xml
ഏതെങ്കിലും UTF-8 സ്ട്രിംഗ് ഇതിനായി ഉപയോഗിക്കാം KEY ഒപ്പം , VALUE-.

പിന്തുണച്ചു ഡി-ബസ് വ്യാഖ്യാനങ്ങൾ

ഇനിപ്പറയുന്ന ഡി-ബസ് വ്യാഖ്യാനങ്ങൾ പിന്തുണയ്ക്കുന്നു gdbus-codegen:

org.freedesktop.DBus.ഒഴിവാക്കപ്പെട്ടു
ഏതിലും ഉപയോഗിക്കാം , , ഒപ്പം വ്യക്തമാക്കാനുള്ള ഘടകം
മൂലകത്തിന്റെ മൂല്യം ശരിയാണെങ്കിൽ അത് ഒഴിവാക്കപ്പെടും. ഈ വ്യാഖ്യാനം എന്നത് ശ്രദ്ധിക്കുക
നിർവചിച്ചിരിക്കുന്നത് ഡി-ബസ് സ്പെസിഫിക്കേഷൻ[1] ശരിയും തെറ്റും മൂല്യങ്ങൾ മാത്രമേ അനുമാനിക്കാൻ കഴിയൂ.
പ്രത്യേകിച്ചും, മൂലകത്തെ ഒഴിവാക്കിയ പതിപ്പ് നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയില്ല
ഏതെങ്കിലും സഹായകരമായ നിരാകരണ സന്ദേശം. അത്തരം വിവരങ്ങൾ ഘടകത്തിലേക്ക് ചേർക്കണം
പകരം ഡോക്യുമെന്റേഷൻ.

സി കോഡ് സൃഷ്ടിക്കുമ്പോൾ, ജനറേറ്റഡ് എന്നതിലേക്ക് #G_GNUC_DEPRECATED ചേർക്കാൻ ഈ വ്യാഖ്യാനം ഉപയോഗിക്കുന്നു
മൂലകത്തിനായുള്ള പ്രവർത്തനങ്ങൾ.

ഡോക്ബുക്ക് എക്സ്എംഎൽ സൃഷ്ടിക്കുമ്പോൾ, ഡോക്യുമെന്റേഷനിൽ ഒരു ഒഴിവാക്കൽ മുന്നറിയിപ്പ് ദൃശ്യമാകും
മൂലകത്തിന്.

org.gtk.GDBus.മുതൽ
ഏതിലും ഉപയോഗിക്കാം , , ഒപ്പം വ്യക്തമാക്കാനുള്ള ഘടകം
പതിപ്പ് (ഏതെങ്കിലും സ്വതന്ത്ര-ഫോം സ്ട്രിംഗ്, എന്നാൽ ഒരു പതിപ്പ്-അറിയൽ സോർട്ട് ഫംഗ്ഷൻ ഉപയോഗിച്ച് താരതമ്യം ചെയ്യുമ്പോൾ)
മൂലകം പ്രത്യക്ഷപ്പെട്ടു.

സി കോഡ് സൃഷ്ടിക്കുമ്പോൾ, ഫംഗ്‌ഷൻ പോയിന്റർ ഓർഡർ ഉറപ്പാക്കാൻ ഈ ഫീൽഡ് ഉപയോഗിക്കുന്നു
ABI/API സംരക്ഷിക്കുന്നു, "സ്ഥിരത ഗ്യാരണ്ടികൾ" എന്ന വിഭാഗം കാണുക.

ഡോക്ബുക്ക് XML സൃഷ്ടിക്കുമ്പോൾ, ഈ ടാഗിന്റെ മൂല്യം ഡോക്യുമെന്റേഷനിൽ ദൃശ്യമാകും.

org.gtk.GDBus.DocString
ഡോക്യുമെന്റേഷനായി ഡോക്ബുക്ക് ഉള്ളടക്കമുള്ള ഒരു സ്ട്രിംഗ്. ഈ വ്യാഖ്യാനം ഉപയോഗിക്കാവുന്നതാണ്
, , , ഒപ്പം ഘടകങ്ങൾ.

org.gtk.GDBus.DocString.Short
ഹ്രസ്വ/ഹ്രസ്വമായ ഡോക്യുമെന്റേഷനായി ഡോക്ബുക്ക് ഉള്ളടക്കമുള്ള ഒരു സ്ട്രിംഗ്. ഈ വ്യാഖ്യാനത്തിന് മാത്രമേ കഴിയൂ
ഉപയോഗിക്കും ഘടകങ്ങൾ.

org.gtk.GDBus.C.Name
ഏതിലും ഉപയോഗിക്കാം , , ഒപ്പം വ്യക്തമാക്കാനുള്ള ഘടകം
സി കോഡ് സൃഷ്ടിക്കുമ്പോൾ ഉപയോഗിക്കേണ്ട പേര്. മൂല്യം ഉണ്ടായിരിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു ഒട്ടക കേസ്[4] അല്ലെങ്കിൽ
അഗ്ലി_കേസ് (മുകളിൽ കാണുന്ന).

org.gtk.GDBus.C.ForceGVariant
ശൂന്യമല്ലാത്ത സ്‌ട്രിംഗിലേക്ക് സജ്ജീകരിക്കുകയാണെങ്കിൽ, സ്വാഭാവികമായതിന് പകരം #GVariant ഉദാഹരണം ഉപയോഗിക്കും
സി തരം. ഈ വ്യാഖ്യാനം ഏത് കാര്യത്തിലും ഉപയോഗിക്കാം ഒപ്പം ഘടകം.

org.gtk.GDBus.C.UnixFD
ശൂന്യമല്ലാത്ത സ്‌ട്രിംഗിലേക്ക് സജ്ജീകരിച്ചാൽ, ജനറേറ്റ് ചെയ്‌ത കോഡിൽ കൈമാറ്റം ചെയ്യാനുള്ള പാരാമീറ്ററുകൾ ഉൾപ്പെടും
#GUnixFDList തരം ഉപയോഗിക്കുന്ന ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ. ഈ വ്യാഖ്യാനം ഉപയോഗിക്കാവുന്നതാണ്
ഘടകങ്ങൾ.

org.gtk.GDBus.DocString വ്യാഖ്യാനം ഉപയോഗിക്കുന്നതിനുള്ള എളുപ്പമുള്ള ബദലായി, പാഴ്സർ ശ്രദ്ധിക്കുക
ഉപയോഗിച്ചത് gdbus-codegen സമാനമായ രീതിയിൽ XML അഭിപ്രായങ്ങൾ പാഴ്‌സ് ചെയ്യുന്നു gtk-doc[രണ്ട്]:

ഏതൊരു ഇൻലൈൻ ഡോക്യുമെന്റേഷൻ ബിറ്റിലും (ഉദാ: ഇന്റർഫേസുകൾക്ക്, @sce) ഉപയോഗിക്കാമെന്നത് ശ്രദ്ധിക്കുക
org.gtk.GDBus സജ്ജീകരിക്കുന്നതിനുള്ള രീതികൾ, സിഗ്നലുകൾ, പ്രോപ്പർട്ടികൾ. വ്യാഖ്യാനം മുതൽ. വേണ്ടി
org.gtk.GDBus.DocString വ്യാഖ്യാനം (ഒപ്പം ഇൻലൈൻ കമന്റുകളും), ഫോമിന്റെ സബ്‌സ്ട്രിംഗുകൾ ശ്രദ്ധിക്കുക
#net.Corp.Bar, net.Corp.Bar.FooMethod(), #net.Corp.Bar::BarSignal ഒപ്പം
#net.Corp.InlineDocs:BazProperty എല്ലാം ബന്ധപ്പെട്ട ഇന്റർഫേസിലേക്കുള്ള ലിങ്കുകളിലേക്ക് വികസിപ്പിച്ചിരിക്കുന്നു,
രീതി, സിഗ്നൽ, സ്വത്ത്. കൂടാതെ, @, % പ്രതീകങ്ങൾ എന്നിവയിൽ ആരംഭിക്കുന്ന സബ്‌സ്‌ട്രിംഗുകളാണ്
ആയി റെൻഡർ ചെയ്തു പാരാമീറ്റർ[6] ഒപ്പം സ്ഥിരമായ[7] യഥാക്രമം.

XML അഭിപ്രായങ്ങളും org.gtk.GDBus.DocString അല്ലെങ്കിൽ org.gtk.GDBus.DocString.Short എന്നിവയും ആണെങ്കിൽ
വ്യാഖ്യാനങ്ങൾ നിലവിലുണ്ട്, രണ്ടാമത്തേത് വിജയിക്കുന്നു.

ഉദാഹരണം

ഇനിപ്പറയുന്ന D-Bus Introspection XML പരിഗണിക്കുക.


















If gdbus-codegen ഈ ഫയലിൽ ഇതുപോലെ ഉപയോഗിക്കുന്നു:

gdbus-codegen --generate-c-code myapp-generated
--c-namespace MyApp
--interface-prefix net.corp.MyApp.
net.Corp.MyApp.Frobber.xml

myapp-generated[ch] എന്ന് വിളിക്കപ്പെടുന്ന രണ്ട് ഫയലുകൾ ജനറേറ്റ് ചെയ്യപ്പെടുന്നു. ഫയലുകൾ ഒരു സംഗ്രഹം നൽകുന്നു
#GTypeInterface - derived type എന്ന് വിളിക്കുന്നു MyAppFrobber അതുപോലെ രണ്ട് തൽക്ഷണ തരങ്ങൾ
അതേ പേര് എന്നാൽ പ്രത്യയത്തിൽ ചേർത്തിരിക്കുന്നു പ്രോക്സി ഒപ്പം അസ്ഥികൂടം. ജനറേറ്റ് ചെയ്ത ഫയലിൽ, ഏകദേശം, അടങ്ങിയിരിക്കുന്നു
ഇനിപ്പറയുന്ന സൗകര്യങ്ങൾ:

/* സൃഷ്‌ടിച്ച മൂന്ന് തരങ്ങൾക്കായുള്ള ജിടൈപ്പ് മാക്രോകൾ */
#MY_APP_TYPE_FROBBER നിർവ്വചിക്കുക (എന്റെ_ആപ്പ്_ഫ്രോബർ_ഗെറ്റ്_ടൈപ്പ് ())
#നിർവ്വചിക്കുക MY_APP_TYPE_FROBBER_SKELETON (എന്റെ_ആപ്പ്_ഫ്രോബർ_സ്കെലിറ്റൺ_ഗെറ്റ്_ടൈപ്പ് ())
#MY_APP_TYPE_FROBBER_PROXY നിർവ്വചിക്കുക (എന്റെ_ആപ്പ്_ഫ്രോബർ_പ്രോക്സി_ഗെറ്റ്_ടൈപ്പ് ())

ടൈപ്പ്ഡെഫ് സ്ട്രക്റ്റ് _MyAppFrobber MyAppFrobber; /* ഡമ്മി ടൈപ്പ്ഡെഫ് */

ടൈപ്പ്ഡെഫ് ഘടന
{
GTypeInterface parent_face;

/* :: അറിയിപ്പ് സിഗ്നലിനായുള്ള സിഗ്നൽ ഹാൻഡ്‌ലർ */
അസാധുവാണ് (*അറിയിപ്പ്) (MyAppFrobber *proxy,
GVariant *icon_blob,
ചെറിയ ഉയരം,
const gchar* const * സന്ദേശങ്ങൾ);

/* ::handle-hello-world സിഗ്നലിനായുള്ള സിഗ്നൽ ഹാൻഡ്‌ലർ */
gboolean (*handle_hello_world) (MyAppFrobber *proxy,
GDBusMethodInvocation *invocation,
const gchar * ആശംസകൾ);
} MyAppFrobberIface;

/* അസമന്വിതമായി HelloWorld() എന്ന് വിളിക്കുന്നു */
ശൂന്യം
my_app_frobber_call_hello_world (MyAppFrobber *proxy,
const gchar * ആശംസകൾ,
GCancellable *cancelable,
GAsyncReadyCallback കോൾബാക്ക്,
gpointer user_data);
gboolean
my_app_frobber_call_hello_world_finish (MyAppFrobber *proxy,
gchar ** out_response,
GAsyncResult *res,
തെറ്റ് ** പിശക്);

/* Synchronously HelloWorld() എന്ന് വിളിക്കുന്നു. കോളിംഗ് ത്രെഡ് തടയുന്നു. */
gboolean
my_app_frobber_call_hello_world_sync (MyAppFrobber *proxy,
const gchar * ആശംസകൾ,
gchar ** out_response,
GCancellable *cancelable,
തെറ്റ് ** പിശക്);

/* HelloWorld() രീതി കോൾ കൈകാര്യം ചെയ്യുന്നത് പൂർത്തിയാക്കുന്നു */
ശൂന്യം
my_app_frobber_complete_hello_world (MyAppFrobber *object,
GDBusMethodInvocation *invocation,
const gchar *പ്രതികരണം);

/* :: അറിയിപ്പ് സിഗ്നൽ / അറിയിപ്പ് () ഡി-ബസ് സിഗ്നൽ */ പുറപ്പെടുവിക്കുന്നു
ശൂന്യം
my_app_frobber_emit_notification (MyAppFrobber *object,
GVariant *icon_blob,
ചെറിയ ഉയരം,
const gchar* const * സന്ദേശങ്ങൾ);

/* :verbose GObject പ്രോപ്പർട്ടി / Verbose D-Bus പ്രോപ്പർട്ടി ലഭിക്കുന്നു.
* I/O തടയുന്നില്ല.
*/
gboolean my_app_frobber_get_verbose (MyAppFrobber *object);

/* :verbose GObject പ്രോപ്പർട്ടി / Verbose D-Bus പ്രോപ്പർട്ടി സജ്ജീകരിക്കുന്നു.
* I/O തടയുന്നില്ല.
*/
അസാധുവായ my_app_frobber_set_verbose (MyAppFrobber *object,
gboolean മൂല്യം);

/* ഇന്റർഫേസ് വിവരം ലഭിക്കുന്നു */
GDBusInterfaceInfo *my_app_frobber_interface_info (അസാധു);

/* ഒരു പുതിയ അസ്ഥികൂടം ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു, കയറ്റുമതി ചെയ്യാൻ തയ്യാറാണ് */
MyAppFrobber *my_app_frobber_skeleton_new (അസാധു);

/* ക്ലയന്റ്-സൈഡ് പ്രോക്സി കൺസ്ട്രക്റ്ററുകൾ.
*
* കൂടാതെ, _new_for_bus(), _new_for_bus_finish() കൂടാതെ
* _new_for_bus_sync() പ്രോക്‌സി കൺസ്ട്രക്‌റ്ററുകളും സൃഷ്‌ടിക്കുന്നു.
*/
ശൂന്യം
my_app_frobber_proxy_new (GDBusConnection *കണക്ഷൻ,
GDBusProxyFlags പതാകകൾ,
const gchar *പേര്,
const gchar *object_path,
GCancellable *cancelable,
GAsyncReadyCallback കോൾബാക്ക്,
gpointer user_data);
MyAppFrobber*
my_app_frobber_proxy_new_finish (GAsyncResult *res,
തെറ്റ് ** പിശക്);
MyAppFrobber*
my_app_frobber_proxy_new_sync (GDBusConnection *കണക്ഷൻ,
GDBusProxyFlags പതാകകൾ,
const gchar *പേര്,
const gchar *object_path,
GCancellable *cancelable,
തെറ്റ് ** പിശക്);

അങ്ങനെ, ഓരോ ഡി-ബസ് രീതിക്കും, രീതിയെ വിളിക്കുന്നതിന് മൂന്ന് സി ഫംഗ്ഷനുകൾ ഉണ്ടാകും, ഒന്ന്
ഒരു ഇൻകമിംഗ് കോൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള #GObject സിഗ്നലും ഒരു C ഫംഗ്‌ഷനും പൂർത്തിയാക്കാൻ
ഇൻകമിംഗ് കോൾ. ഓരോ ഡി-ബസ് സിഗ്നലിനും ഒരു #GObject സിഗ്നലും ഒരു C ഫംഗ്ഷനും ഉണ്ട്
അത് പുറത്തുവിടുന്നു. ഓരോ ഡി-ബസ് പ്രോപ്പർട്ടിക്കും, രണ്ട് സി ഫംഗ്‌ഷനുകൾ ജനറേറ്റുചെയ്യുന്നു (ഒരു സെറ്റർ, ഒന്ന്
getter) കൂടാതെ ഒരു #GObject പ്രോപ്പർട്ടി. ഇനിപ്പറയുന്ന പട്ടിക സൃഷ്ടിച്ച സൗകര്യങ്ങളെ സംഗ്രഹിക്കുന്നു
കൂടാതെ അവ എവിടെയാണ് ബാധകമാകുന്നത്:

┌─────────────────────┬─────────────────────────┬─ ───────────────────────────┐
│ │ ക്ലയന്റ് │ സെർവർ │
├─────────────────────┼─────────────────────────┼─ ────────────────────────────
│തരങ്ങൾ │ ഉപയോഗിക്കുക MyAppFrobberProxy │ ഏത് തരത്തിലും നടപ്പിലാക്കുന്നു │
│ │ │ ദി MyAppFrobber │
│ │ │ ഇന്റർഫേസ് │
├─────────────────────┼─────────────────────────┼─ ────────────────────────────
│രീതികൾ │ ഉപയോഗിക്കുക m_a_f_hello_world() │ വഴി സ്വീകരിക്കുക
│ │ വിളിക്കാൻ. │ handle_hello_world() │
│ │ │ സിഗ്നൽ ഹാൻഡ്ലർ. പൂർണ്ണം │
│ │ │ │ ഉപയോഗിച്ചുള്ള കോൾ
│ │ │ m_a_f_complete_hello_world() │
├─────────────────────┼─────────────────────────┼─ ────────────────────────────
│സിഗ്നലുകൾ │ കണക്റ്റുചെയ്യുക │ ഉപയോഗിക്കുക │
│ │ :: അറിയിപ്പ് GOobject │ m_a_f_emit_notification() ലേക്ക് │
│ │ സിഗ്നൽ. │ സിഗ്നൽ പുറപ്പെടുവിക്കുക. │
├─────────────────────┼─────────────────────────┼─ ────────────────────────────
│പ്രോപ്പർട്ടികൾ (വായന) │ ഉപയോഗിക്കുക m_a_f_get_verbose() │ #GObject's │ നടപ്പിലാക്കുക
│ │ അല്ലെങ്കിൽ : വാചാലമായ. │ get_property() vfunc. │
├─────────────────────┼─────────────────────────┼─ ────────────────────────────
│പ്രോപ്പർട്ടികൾ (എഴുത്ത്) │ ഉപയോഗിക്കുക m_a_f_set_verbose() │ #GObject's │ നടപ്പിലാക്കുക
│ │ അല്ലെങ്കിൽ : വാചാലമായ. │ set_property() vfunc. │
└─────────────────────┴─────────────────────────┴─ ───────────────────────────┘

ക്ലയന്റ്-സൈഡ് ഉപയോഗം
ജനറേറ്റ് ചെയ്‌ത കൺസ്‌ട്രക്‌ടറുകൾക്കൊപ്പം നിങ്ങൾക്ക് സൃഷ്‌ടിച്ച പ്രോക്‌സി തരം ഉപയോഗിക്കാം:

MyAppFrobber *പ്രോക്സി;
തെറ്റ് *പിശക്;

പിശക് = NULL;
പ്രോക്സി = my_app_frobber_proxy_new_for_bus_sync (
G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
"net.Corp.MyApp", /* ബസിന്റെ പേര് */
"/net/Corp/MyApp/SomeFrobber", /* വസ്തു */
NULL, /* GCancellable* */
&പിശക്);
/* പ്രോക്സി ഉപയോഗിച്ച് കാര്യങ്ങൾ ചെയ്യുക */
g_object_unref (പ്രോക്സി);

ജനറിക് #GDBusProxy സൗകര്യങ്ങൾ ഉപയോഗിക്കുന്നതിന് പകരം, ജനറേറ്റ് ചെയ്ത രീതികൾ ഉപയോഗിക്കാം
അതുപോലെ my_app_frobber_call_hello_world() അഭ്യർത്ഥിക്കാൻ
net.Corp.MyApp.Frobber.HelloWorld() ഡി-ബസ് രീതി, ലേക്ക് ബന്ധിപ്പിക്കുക :: അറിയിപ്പ്
സ്വീകരിക്കാനുള്ള GObject സിഗ്നൽ net.Corp.MyApp.Frobber::അറിയിപ്പ് ഡി-ബസ് സിഗ്നൽ, നേടുക/സജ്ജീകരിക്കുക
The net.Corp.MyApp.Frobber:Verbose GObject പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ഡി-ബസ് പ്രോപ്പർട്ടി
: വാചാലമായ അഥവാ my_app_get_verbose() ഒപ്പം my_app_set_verbose() രീതികൾ. സ്റ്റാൻഡേർഡ് ഉപയോഗിക്കുക
#GObject::വസ്തു മാറ്റങ്ങൾ കേൾക്കാൻ സിഗ്നൽ അറിയിക്കുക.

എല്ലാ പ്രോപ്പർട്ടി ആക്‌സസ്സും #GDBusProxy-യുടെ പ്രോപ്പർട്ടി കാഷെ വഴിയാണെന്ന കാര്യം ശ്രദ്ധിക്കുക, അതിനാൽ ഒരിക്കലും I/O ഒന്നും ചെയ്തിട്ടില്ല
പ്രോപ്പർട്ടികൾ വായിക്കുമ്പോൾ. ഒരു പ്രോപ്പർട്ടി ക്രമീകരിക്കുന്നതിന് കാരണമാകുമെന്നതും ശ്രദ്ധിക്കുക
org.freedesktop.DBus.Properties.Set[8] റിമോട്ട് ഒബ്‌ജക്‌റ്റിൽ വിളിക്കേണ്ട രീതി. ഈ
എന്നിരുന്നാലും, കോൾ അസമന്വിതമാണ്, അതിനാൽ ഒരു പ്രോപ്പർട്ടി സജ്ജീകരിക്കുന്നത് തടയില്ല. കൂടാതെ, മാറ്റം
കാലതാമസം കൂടാതെ പിശക് പരിശോധിക്കുന്നത് സാധ്യമല്ല.

സെർവർ സൈഡ് ഉപയോഗം
സൃഷ്ടിച്ചത് MyAppFrobber ഇന്റർഫേസ് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നതിനാൽ ഇത് എയിൽ നടപ്പിലാക്കാൻ എളുപ്പമാണ്
#GObject ഉപവിഭാഗം. ഉദാഹരണത്തിന്, കൈകാര്യം ചെയ്യാൻ ഹലോ വേൾഡ്() രീതി ഇൻവോക്കേഷനുകൾ, vfunc സജ്ജമാക്കുക
വേണ്ടി handle_hello_hello_world() ലെ MyAppFrobberIface ഘടന. സമാനമായി, കൈകാര്യം ചെയ്യാൻ
net.Corp.MyApp.Frobber:Verbose സ്വത്ത് അസാധുവാക്കുന്നു : വാചാലമായ #GObject പ്രോപ്പർട്ടി നിന്ന്
ഉപവിഭാഗം. ഒരു സിഗ്നൽ പുറപ്പെടുവിക്കാൻ, ഉപയോഗിക്കുക ഉദാ my_app_emit_signal() അല്ലെങ്കിൽ g_signal_emit_by_name().

ഉപവിഭാഗത്തിനുപകരം, ജനറേറ്റഡ് ഉപയോഗിക്കുന്നത് പലപ്പോഴും എളുപ്പമാണ് MyAppFrobberSkeleton
ഉപവിഭാഗം. ഇൻകമിംഗ് രീതി കോളുകൾ കൈകാര്യം ചെയ്യാൻ, ഉപയോഗിക്കുക g_signal_connect() കൂടെ ::ഹാൻഡിൽ-*
#GObject ന്റെ അസാധുവാക്കലിന് പകരം സിഗ്നലുകൾ get_property() ഒപ്പം set_property() vfuncs,
g_object_get(), g_object_set() അല്ലെങ്കിൽ ജനറേറ്റഡ് പ്രോപ്പർട്ടി ഗെറ്ററുകളും സെറ്ററുകളും ഉപയോഗിക്കുക
ജനറേറ്റഡ് ക്ലാസിന് ഒരു ആന്തരിക പ്രോപ്പർട്ടി ബാഗ് നടപ്പിലാക്കൽ ഉണ്ട്).

സ്റ്റാറ്റിക് ഗ്ബൂലിയൻ
on_handle_hello_world (MyAppFrobber *ഇന്റർഫേസ്,
GDBusMethodInvocation *invocation,
const gchar * ആശംസകൾ,
gpointer user_data)
{
എങ്കിൽ (g_strcmp0 (ആശംസകൾ, "ബൂ") != 0)
{
gchar *പ്രതികരണം;
പ്രതികരണം = g_strdup_printf ("വാക്ക്! നിങ്ങൾ `%s' എന്ന് പറഞ്ഞു.", ആശംസകൾ);
my_app_complete_hello_world (ഇന്റർഫേസ്, ഇൻവോക്കേഷൻ, പ്രതികരണം);
g_free (പ്രതികരണം);
}
മറ്റാരെങ്കിലും
{
g_dbus_method_invocation_return_error (invocation,
MY_APP_ERROR,
MY_APP_ERROR_NO_WHINING,
"ഹേയ്, %s, അവിടെ ഞരക്കമുണ്ടാകില്ല!",
g_dbus_method_invocation_get_sender (invocation));
}
TRUE തിരികെ നൽകുക;
}

[...]

ഇന്റർഫേസ് = my_app_frobber_skeleton_new ();
my_app_frobber_set_verbose (ഇന്റർഫേസ്, TRUE);

g_signal_connect (ഇന്റർഫേസ്,
"ഹാൻഡിൽ-ഹലോ-വേൾഡ്",
G_CALLBACK (on_handle_hello_world),
ചില_ഉപയോക്തൃ_ഡാറ്റ);

[...]

പിശക് = NULL;
എങ്കിൽ (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (ഇന്റർഫേസ്),
കണക്ഷൻ,
"/path/of/dbus_object",
&പിശക്))
{
/* കൈകാര്യം പിശക് */
}

ആറ്റോമിക് മാറ്റങ്ങളെ സുഗമമാക്കുന്നതിന് (ഒരേ സമയം മാറുന്ന ഒന്നിലധികം ഗുണങ്ങൾ),
#GObject::notify സിഗ്നലുകൾ ലഭിക്കുമ്പോൾ ക്യൂവിൽ നിൽക്കുന്നു. ക്യൂ ഒഴിഞ്ഞുകിടക്കുന്നു
ഹാൻഡ്‌ലർ (ഇത് ത്രെഡിന്റെ ത്രെഡ് ഡിഫോൾട്ട് മെയിൻ ലൂപ്പിൽ നിന്ന് വിളിക്കപ്പെടുന്നു
അസ്ഥികൂടം ഒബ്‌ജക്‌റ്റ് നിർമ്മിച്ചു) ഇത് ഉദ്വമനത്തിന് കാരണമാകും
org.freedesktop.DBus.Properties ::PropertiesChanged[8] എല്ലാ ഗുണങ്ങളുമുള്ള സിഗ്നൽ
മാറിയിട്ടുണ്ട്. ഇതിനായി g_dbus_interface_skeleton_flush() അല്ലെങ്കിൽ g_dbus_object_skeleton_flush() ഉപയോഗിക്കുക
ഉടൻ ക്യൂ ശൂന്യമാക്കുക. ഇതിനായി g_object_freeze_notify(), g_object_thaw_notify() എന്നിവ ഉപയോഗിക്കുക
മറ്റൊരു ത്രെഡിലാണെങ്കിൽ ആറ്റോമിക് മാറ്റങ്ങൾ.

C തരം മാപ്പിംഗ്

സ്കെയിലർ തരങ്ങൾ (തരം-സ്ട്രിംഗുകൾ 'b', 'y', 'n', 'q', 'i', 'u', 'x', 't', 'd') ), സ്ട്രിംഗുകൾ
(ടൈപ്പ്-സ്ട്രിംഗുകൾ 's', 'ay', 'o', 'g' എന്നിവയും സ്ട്രിംഗിന്റെ അറേകളും (ടൈപ്പ്-സ്ട്രിംഗുകൾ 'as', 'ao' ഒപ്പം
'aay') സ്വാഭാവിക തരങ്ങളിലേക്ക് മാപ്പ് ചെയ്‌തിരിക്കുന്നു, ഉദാ #gboolean, #gdouble, #gint, gchar*, gchar**
ഇത്യാദി. മറ്റെല്ലാം #GVariant തരത്തിലേക്ക് മാപ്പ് ചെയ്തിരിക്കുന്നു.

വ്യാഖ്യാനം ഉപയോഗിച്ച് ഈ ഓട്ടോമാറ്റിക് മാപ്പിംഗ് ഓഫാക്കാനാകും
org.gtk.GDBus.C.ForceGVariant - ഉപയോഗിക്കുകയാണെങ്കിൽ, പകരം ഒരു #GVariant എപ്പോഴും കൈമാറ്റം ചെയ്യപ്പെടും
അനുബന്ധ നേറ്റീവ് സി തരം. ഈ വ്യാഖ്യാനം ഉപയോഗിക്കുമ്പോൾ ഉപയോഗിക്കാൻ സൗകര്യപ്രദമായിരിക്കും
NUL ബൈറ്റുകൾ ഉൾച്ചേർക്കാവുന്ന ഡാറ്റയ്ക്കുള്ള ബൈടെസ്‌ട്രിംഗുകൾ (ടൈപ്പ്-സ്ട്രിംഗ് 'ay').

സ്ഥിരത ഗ്യാരണ്ടികൾ

ജനറേറ്റ് ചെയ്‌ത സി ഫംഗ്‌ഷനുകൾ അവയുടെ എബിഐ മാറ്റില്ലെന്ന് ഉറപ്പുനൽകുന്നു, അതായത്, ഒരു രീതി,
സിഗ്നലോ പ്രോപ്പർട്ടിയോ ഇൻട്രോസ്പെക്ഷൻ XML-ൽ അതിന്റെ ഒപ്പ് മാറ്റില്ല, സൃഷ്ടിച്ച C
ഫംഗ്‌ഷനുകൾ അതിന്റെ C ABI-യെയും മാറ്റില്ല. ജനറേറ്റ് ചെയ്‌ത ഉദാഹരണത്തിന്റെയും ക്ലാസിന്റെയും എബിഐ
ഘടനകളും സംരക്ഷിക്കപ്പെടും.

org.gtk.GDBus. മുതൽ സൃഷ്‌ടിച്ച #GTypes-ന്റെ ABI സംരക്ഷിക്കപ്പെടും.
വ്യാഖ്യാനം യുക്തിസഹമായി ഉപയോഗിക്കുന്നു - #GInterface-നുള്ള VTable ആശ്രയിക്കുന്നതിനാലാണിത്.
സിഗ്നൽ ഹാൻഡ്ലറുകൾക്കുള്ള ഫംഗ്ഷൻ പോയിന്ററുകൾ. പ്രത്യേകമായി, ഒരു ഡി-ബസ് രീതി ആണെങ്കിൽ, പ്രോപ്പർട്ടി അല്ലെങ്കിൽ
സിഗ്നൽ അല്ലെങ്കിൽ ഒരു ഡി-ബസ് ഇന്റർഫേസിലേക്ക് ചേർത്തു, തുടർന്ന് ജനറേറ്റഡ് #GInterface തരത്തിന്റെ ABI ആണ്
ഓരോ ചേർത്ത രീതിയിലും പ്രോപ്പർട്ടി സിഗ്നൽ വ്യാഖ്യാനിച്ചാൽ മാത്രം സംരക്ഷിച്ചിരിക്കുന്നു
org.gtk.GDBus. മുൻ പതിപ്പുകളേക്കാൾ വലിയ പതിപ്പ് നമ്പർ ഉപയോഗിക്കുന്നതിനാൽ വ്യാഖ്യാനം.

ജനറേറ്റ് ചെയ്‌ത C കോഡ് നിലവിൽ വ്യാഖ്യാനിച്ചിരിക്കുന്നു gtk-doc[5] / ജിഒബ്ജക്റ്റ്
ബോധം[9] അഭിപ്രായങ്ങൾ / വ്യാഖ്യാനങ്ങൾ. ഇതിൽ ലേഔട്ടും ഉള്ളടക്കവും മാറിയേക്കാം
ഭാവി ആയതിനാൽ ഉദാ സെക്ഷൻ ഉപയോഗം മുതലായവയെക്കുറിച്ച് യാതൊരു ഉറപ്പും നൽകിയിട്ടില്ല.

ഡി-ബസ് ഇന്റർഫേസുകൾക്കായി ജനറേറ്റ് ചെയ്‌ത ഡോക്‌ബുക്ക് മാറുമെന്ന് പ്രതീക്ഷിക്കുന്നില്ലെങ്കിലും, ഗ്യാരണ്ടികളൊന്നുമില്ല
ഈ ഘട്ടത്തിൽ നൽകിയിരിക്കുന്നു.

ജനറേറ്റുചെയ്‌ത കോഡ് പുനരവലോകനത്തിലേക്ക് പരിശോധിക്കാൻ പാടില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്
നിയന്ത്രണ സംവിധാനങ്ങൾ, അല്ലെങ്കിൽ അത് വിതരണം ചെയ്ത ഉറവിട ആർക്കൈവുകളിൽ ഉൾപ്പെടുത്തരുത്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് gdbus-codegen ഓൺലൈനിൽ ഉപയോഗിക്കുക