Both sides previous revision
Poprzednia wersja
Nowa wersja
|
Poprzednia wersja
|
pl:miw:miw08_prolog_xml [2008/06/05 17:58] miw |
pl:miw:miw08_prolog_xml [2019/06/27 15:50] (aktualna) |
====== Opis ====== | ====== Opis ====== |
| __**Projekt zakończony**__ |
| |
Wojciech Szymański <wojtek.szym@gmail.com> | Wojciech Szymański <wojtek.szym@gmail.com> |
| |
| |
Celem projektu było omówienie metod parsowania, generowania oraz przetwarzania XML/SGML w Prologu. Należało porównać i przetestować dostępne rozwiązania oraz sprawdzić czy posiadają wsparcie dla DOM, XSD, XSL oraz namespaces. Istotną częścią projektu była implementacja własnego API przeznaczonego do tworzenia dokumentów XML w SWI-Prolog. Okazało się bowiem, że dostępne rozwiązania posiadają przede wszystkim dobre mechanizmy parsowania dokumentu (tworzenia postaci prologowej) oraz jego przetwarzania - zamiany postaci prologowej na dokument XML, natomiast nie posiadają wsparcia dla generowania XML opartego o standard DOM. | Celem projektu było omówienie metod parsowania, generowania oraz przetwarzania XML/SGML w Prologu. Należało porównać i przetestować dostępne rozwiązania oraz sprawdzić czy posiadają wsparcie dla DOM, XSD, XSL oraz namespaces. Istotną częścią projektu była implementacja własnego API przeznaczonego do tworzenia dokumentów XML w SWI-Prolog. Okazało się bowiem, że dostępne rozwiązania posiadają przede wszystkim dobre mechanizmy parsowania dokumentu (tworzenia postaci prologowej) oraz jego przetwarzania - zamiany postaci prologowej na dokument XML, natomiast nie posiadają wsparcia dla generowania XML opartego o standard DOM. |
| |
| |
| |
</code> | </code> |
| |
Przetestowano następujące implementacje prologu: SWI-Prolog, BProlog, Amzi! Prolog, EZY Prolog, MINERVA, JIProlog oraz YAP Prolog. | Przetestowano następujące implementacje prologu: SWI-Prolog, BProlog, Amzi! Prolog, MINERVA, JIProlog oraz YAP Prolog. |
| |
| |
==== SWI-Prolog ==== | ==== SWI-Prolog ==== |
| |
SWI-Prolog posiada pakiet //**sgml2pl**// - [[http://www.swi-prolog.org/packages/sgml2pl.html|SWI-Prolog SGML/XML parser]]. Pakiet ten posiada możliwości parsowania dokumentów XML wraz z namespaces oraz plików XML opartych o model DOM. Podstawowym predykatem służącym do parsowania jest: //**load_xml_file(+File,-ListOfContents)**//. Natomiast predykat służący do przetworzenia postaci prologowej na postać xml ma postać: //**xml_write(+Stream, +Term, +Options)**//. | SWI-Prolog posiada pakiet //**sgml2pl**// - [[http://www.swi-prolog.org/packages/sgml2pl.html|SWI-Prolog SGML/XML parser]]. Pakiet ten posiada możliwości parsowania dokumentów XML wraz z namespaces oraz plików XML opartych o model DOM. Podstawowym predykatem służącym do parsowania jest: //**load_xml_file(+File,-ListOfContents)**//. Natomiast predykat służący do przetworzenia postaci prologowej na dokument XML ma postać: //**xml_write(+Stream, +Term, +Options)**//. |
| |
Po wpisaniu w prologu: | Po wpisaniu w prologu: |
</code> | </code> |
i otrzymujemy dokument XML o nazwie cd1 stanowiący kopię dokumentu cd.xml (Dokument został sparsowany, a następnie zapisany do pliku o nowej nazwie ). | i otrzymujemy dokument XML o nazwie cd1 stanowiący kopię dokumentu cd.xml (Dokument został sparsowany, a następnie zapisany do pliku o nowej nazwie ). |
| |
| |
| |
| |
| |
==== BProlog ==== | ==== BProlog ==== |
Udało się zainstalować BProlog oraz załadować biblioteke 'xml.pl'. Po sparsowaniu pliku 'cd.xml' otrzymano reprezentacje tego pliku xml w postaci termu w prologu. | Implementacja BProlog posiada bibliotekę o nazwie //**xml.pl**//. Podstawowym predykatem do parsowania plików XML jest: //**xml2pl(Input,Output)**//. Jako parametr //Input// podajemy plik XML, a jako //Output// - plik, w którym chcemy zapisać prologową strukturę XML. |
Sposób działania: | Poniżej przedstawiono kroki w celu otrzymania struktury XML: |
* Komenda cd(Dir) ustala ścieżke w której pracujemy, np. cd('C:/BProlog/Tools'). Tam muszą znajdować sie zarówno pilik xml jak i plik biblioteki 'xml.pl'. | - Komenda //**cd(Dir)**// ustala ścieżkę, w której pracujemy, np. //**cd('C:/BProlog/Tools')**//. Tam muszą więc znajdować sie zarówno pilik XML jak i plik biblioteki 'xml.pl'. |
* Komenda cl(File) kompiluje i ładuje program, np. cl('xml.pl') kompiluje i ładuje biblioteke 'xml.pl' | - Komenda //**cl(File)**// kompiluje i ładuje program, np. //**cl('xml.pl')**// kompiluje i ładuje bibliotekę 'xml.pl'. |
* Dalej posługujemy się predykatami zawartymi w biblotece, np. xml2pl('cd.xml','nowy.pl') tworzy plik nowy.pl zawierający postać prologową pliku cd.xml. | - Dalej posługujemy się predykatem, np. //**xml2pl('cd.xml','nowy.pl')**// tworzy plik //nowy.pl// zawierający postać prologową pliku cd.xml. |
| |
Poniżej przedstawiono wygenerowaną postać w prologu: | Poniżej przedstawiono wygenerowaną postać w prologu: |
] ). | ] ). |
</code> | </code> |
| Do przetworzenia postaci prologowej na dokument XML służy predykat: //**pl2xml(Document,Codes).**// |
| |
| |
| |
==== Amzi! Prolog ==== | ==== Amzi! Prolog ==== |
Wersja prologu Amzi! jest możliwa do ściągnięcia jako wersja "Free (Never Expires)". Za inne wersje trzeba płacić. Do tej pory nie udało się skorzystać z biblioteki podanej w [[http://www.amzi.com/manuals/amzi7/libs/xml.htm|XML.pro]]. | Wersja prologu Amzi! jest możliwa do ściągnięcia jako wersja "Free (Never Expires)". Za inne wersje trzeba płacić. Amzi! Prolog posiada bibliotekę obsługującą pliki XML:[[http://www.amzi.com/manuals/amzi7/libs/xml.htm|XML.pro]]. |
| Niestety nie udało sie skorzystać z wyżej wymienionej biblioteki. |
| |
| |
| |
==== EZY Prolog ==== | |
Udało sie zainstalować EZY Prolog Suite. Jest to wersja darmowa tzw. EZY Prolog for students. Przetestowano program ezy_zml_laboratory.ezy. Program pozwala na wczytanie pliku xml i jego sparsowanie. | |
| |
| |
==== MINERVA ==== | ==== MINERVA ==== |
Minerva jest licencjonowanym produktem firmy IF Computer Japan. Jest możliwe posiadanie licencji ewaluacyjnej (wolnej od opłaty) ważnej na okres 2 miesięcy. Minerva może być nazwana jako Java Prolog ponieważ dostarcza funkcjonalności Prologu jako klasa Javy. | Minerva jest licencjonowanym produktem firmy IF Computer Japan. Jest możliwe posiadanie licencji ewaluacyjnej (wolnej od opłaty) ważnej na okres 2 miesięcy. Minerva może być nazwana jako Java Prolog ponieważ dostarcza funkcjonalności Prologu jako klasa Javy. |
| |
| Podstawowymi predykatami związanymi z parsowaniem i przetwarzaniem dokumentów XML są: |
| * //**read_xml(XmlStream, XmlTerm)**// - parsowanie pliku XML do postaci prologowej. |
| * //**write_xml(Stream, XmlTerm)**// - przetwarzanie postaci prologowej do pliku XML. |
| |
| Niestety nie przetestowano użycia wyżej wymienionych predykatów. Patrząc jednak na przykłady udostępnione na stronie domowej MINERVY funkcjonalności zaproponowane przez ten produkt nie różnią się od tych użytych np. w SWI-Prolog. |
| |
| Przykładem może być wygenerowana prologowa struktura dokumentu XML po sparsowaniu dokumentu korzystając z predykatu //**read_xml(XmlStream, XmlTerm)**//. |
| |
| <code prolog> |
| document([xml([version = '1.0'])], |
| element(addressbook,[],[ |
| element(address,[telno = '1234567'],[ |
| element(name,[],[chardata('John')]), |
| element(age,[],[chardata('35')])]), |
| element(address,[telno = '3456789',email = 'henriette@ifcomputer.com'],[ |
| element(name,[],[chardata('Henriette')]), |
| element(age,[],[chardata('27')])])]),[]) |
| </code> |
| |
| |
| |
| |
| |
| |
| |
==== JIProlog ==== | ==== JIProlog ==== |
Po zainstalowaniu i uruchomieniu lub po uruchomieniu apletu na stronie parser zadziałał. Wersja tego prologu była bezpłatna, podczas działania wyświetlał sie tylko napis informujący użytkownika, że posiada wersje shareware unregistered. Zgodnie z przykładem udało sie otrzymać postać prologową po sparsowaniu pliku xml. Poszczególne kroki: | JIProlog jest bezpłatnym interpreterem prologu integrującym języki Java i Prolog. Podczas działania wyświetla się tylko napis informujący użytkownika, że posiada wersje shareware unregistered. JIProlog posiada bibliotekę //**jipxxml**// do obsługi plików XML zgodnych z modelem DOM. Podstawowymi predykatami służącymi do parsowania i przetwarzania plików XML są |
* load_library('jipxxml.jar'). - ładowanie biblioteki do obsługi plików xml | * //**xml_read_document(X)**// - parsowanie dokumentu XML do postaci prologu |
* load_library('jipxio.jar'). - ładowanie biblioteki do i/o dla plików | * //**xml_write_document(XMLDoc)**// - przetwarzanie postaci prologowej do pliku XML |
* see('cd.xml'). - otworzenie pliku xml | |
* xml_read_document(X) - przetworzenie dokumentu xml do postaci prologu | |
| |
Istnieje też predykat create_xml_file(X) który zawarty jest w przykładowym programie xml_sample.pl. Predykat ten tworzy plik xml na podstawie termu prologowego. Istnieje też predykat xml_write_document(Handle,Term). | Aby sparsować dokument XML należy kolejno: |
| - Załadować bibliotekę do obsługi XML - //**load_library('jipxxml.jar').**// |
| - Załadować bibliotekę do obsługi input/output plików - //**load_library('jipxio.jar').**// |
| - Otworzyć dokument XML - //**see('cd.xml').**// |
| - Użyć predykatu: //**xml_read_document(X)**// |
| |
Poniżej przedstawiono wygenerowany plik w postaci prologowej: | Poniżej przedstawiono wygenerowany plik w postaci prologowej: |
])) | ])) |
</code> | </code> |
| |
| JIProlog posiada również szereg predykatów związanych z budowaniem plików XML zgodnych z modelem DOM. Najważniejszymi predykatami są: |
| * //**xml_element(Name, Attributes, Children, ElementTerm)**// - tworzenie węzła, obiektu typu element |
| * //**xml_attribute(Name, Value, AttributeTerm)**// - tworzenie obiektu typu atrybut |
| * //**xml_text(Content, TextTerm)**// - tworzenie obiektu typu Text |
| * //**xml_append_child(Child, Element, NewElement)**// - dodawanie dziecka |
| * //**xml_append_attribute(Attribute, Element, NewElement)**// - dodawanie atrybutu |
| * //**xml_document(Version, Encoding, DocType, Root, DocumentTerm)**// - tworzenie obiektu typu Dokument XML |
| |
| Poniżej zamieszczono przykład budowania prostego pliku XML z użyciem wyżej wymienionych predykatów: |
| <code prolog> |
| create_xml_file(X):- |
| tell(X), |
| % create root element |
| xml_element('music_shop', [], [], Root), |
| % create child 1n |
| xml_element('cd', [], [], Cd1), |
| %create attributes |
| xml_attribute('artist', 'Bob Dylan', Att1), |
| xml_attribute('title', 'Empire Burlesque', Att2), |
| xml_attribute('price', '10.90', Att3), |
| % append attributes |
| xml_append_attribute(Att1, Cd1, Cd11), |
| xml_append_attribute(Att2, Cd11, Cd12), |
| xml_append_attribute(Att3, Cd12, Cd13), |
| % create child |
| xml_text('Music CD', Title1), |
| % append child |
| xml_append_child(Title1, Cd13, Cd14), |
| % append children to root |
| xml_append_child(Cd14, Root, Root1), |
| % create document |
| xml_document('1.0', [], [], Root1, Doc), |
| xml_write_document(Doc), |
| told. |
| </code> |
| |
| Z powyższego przykładu otrzymano następujący plik XML: |
| {{:pl:miw:music.xml|Plik XML}} |
| |
| |
| |
| |
==== YAP Prolog ==== | ==== YAP Prolog ==== |
Wersja YAP Prolog jest bezpłatna użyciu w środowiskach akademickich. Istnieje biblioteka posiadająca możliwości związane z plikami XML/HTML (parsowanie plików XML lub HTML) - [[http://www.clip.dia.fi.upm.es/Software/pillow/pillow.html|The PiLLoW Web Programming Library ]]. | Wersja YAP Prolog jest bezpłatna w użyciu w środowiskach akademickich. YAP Prolog dysponuje biblioteką posiadającą możliwości związane z parsowaniem i przetwarzaniem plików XML/HTML [[http://www.clip.dia.fi.upm.es/Software/pillow/pillow.html|The PiLLoW Web Programming Library ]]. |
| |
Wersje tej biblioteki są dostępne zarówno dla YAP Prolog jak i dla SWI Prolog oraz Ciao Prolog. | Wersje tej biblioteki są dostępne zarówno dla YAP Prolog jak i dla SWI Prolog oraz Ciao Prolog. |
| |
Jeśli chodzi o predykaty związane z XML jest dostępny [[http://www.clip.dia.fi.upm.es/Software/pillow/pillow_doc_html/pillow_doc_3.html#SEC5|xml2terms/2]] | Jeśli chodzi o predykaty związane z XML jest dostępny: //**xml2terms(String,Terms)**//[[http://www.clip.dia.fi.upm.es/Software/pillow/pillow_doc_html/pillow_doc_3.html#SEC5|xml2terms]] |
| |
Predykat ten wykorzystuje się na dwa sposoby: | Predykat ten wykorzystuje się na dwa sposoby: |
- translacja XML-term do kodu XML | - translacja XML-term'u do kodu XML |
- translacja kodu XML do strukturalnego termu XML'owego | - translacja kodu XML do strukturalnego termu XML'owego |
| |
| |
===== Porównanie prologowych postaci dokumentu XML ===== | ===== Porównanie prologowych postaci dokumentu XML ===== |
| |
| Porównanie przeprowadzono dla pliku XML wygenerowanego z systemu VARDA-M_1.{{:pl:miw:varda_thermostat.xml|Thermostat}} |
| |
| Do porównania zdecydowano się wykorzystać następujące wersje prologu. |
| |
| - SWI-Prolog - [[http://www.swi-prolog.org/packages/sgml2pl.html]] |
| - BProlog - [[http://www.probp.com/publib/xml.html]] |
| - JIProlog - [[http://www.ugosweb.com/jiprolog/index.aspx]] |
| |
| Wersje te nie posiadają żadnych ograniczeń w użyciu. |
| |
| Otrzymano następujące wyniki: |
| |
| ==== SWI-Prolog ==== |
| |
| |
| Plik XML po sparsowaniu w SWI Prologu za pomocą predykatu //load_xml_file('therm.xml',X)// jest w postaci listy, która składa się z zagnieżdżonych struktur typu //**element(Node_Name, [Value], [child_element])**//, gdzie argumentami są: |
| * //**Node_Name**// - nazwa węzła |
| * //**[Value]**// - lista atrybutów węzła |
| * //**[child_element]**// - lista kolejnych elementów - dzieci lub tekst węzła |
| |
| Poniżej przedstawiono sparsowany plik XML w SWI-Prolog: |
| <code prolog> |
| X = [element(hml, [], [ |
| , element(type_set, [], []), |
| , element(attribute_set, [], [ |
| , element(att, [name=Thermostat, id=att_0, value=single, class=ro], []), |
| , element(att, [name=Time, id=att_1, value=single, class=ro], []), |
| , element(att, [name=Temperature, id=att_2, value=single, class=ro], []), |
| , element(att, [name=Date, id=att_3, value=single, class=ro], []), |
| , element(att, [name=Hour, id=att_4, value=single, class=ro], []), |
| , element(att, [name=season, id=att_5, value=single, class=ro], []), |
| , element(att, [name=operation, id=att_6, value=single, class=ro], []), |
| , element(att, [name=thermostat_settings, id=att_7, value=single, class=ro], []), |
| , element(att, [name=day, id=att_8, value=single, class=ro], []), |
| , element(att, [name=month, id=att_9, value=single, class=ro], []), |
| , element(att, [name=today, id=att_10, value=single, class=ro], []), |
| , element(att, [name=hour, id=att_11, value=single, class=ro], []), |
| ]), |
| , element(property_set, [], [ |
| , element(property, [id=prp_0], [ |
| , element(attref, [ref=att_0], []), |
| ]), |
| , element(property, [id=prp_1], [ |
| , element(attref, [ref=att_1], []), |
| , element(attref, [ref=att_2], []), |
| ]), |
| , element(property, [id=prp_2], [ |
| , element(attref, [ref=att_1], []), |
| ]), |
| , element(property, [id=prp_3], [ |
| , element(attref, [ref=att_2], []), |
| ]), |
| , element(property, [id=prp_4], [ |
| , element(attref, [ref=att_3], []), |
| , element(attref, [ref=att_4], []), |
| , element(attref, [ref=att_5], []), |
| , element(attref, [ref=att_6], []), |
| ]), |
| , element(property, [id=prp_5], [ |
| , element(attref, [ref=att_3], []), |
| , element(attref, [ref=att_4], []), |
| ]), |
| , element(property, [id=prp_6], [ |
| , element(attref, [ref=att_5], []), |
| , element(attref, [ref=att_6], []), |
| ]), |
| , element(property, [id=prp_7], [ |
| , element(attref, [ref=att_7], []), |
| ]), |
| , element(property, [id=prp_8], [ |
| , element(attref, [ref=att_5], []), |
| ]), |
| , element(property, [id=prp_9], [ |
| , element(attref, [ref=att_6], []), |
| ]), |
| , element(property, [id=prp_10], [ |
| , element(attref, [ref=att_3], []), |
| ]), |
| , element(property, [id=prp_11], [ |
| , element(attref, [ref=att_4], []), |
| ]), |
| , element(property, [id=prp_12], [ |
| , element(attref, [ref=att_8], []), |
| , element(attref, [ref=att_9], []), |
| , element(attref, [ref=att_10], []), |
| ]), |
| , element(property, [id=prp_13], [ |
| , element(attref, [ref=att_9], []), |
| ]), |
| , element(property, [id=prp_14], [ |
| , element(attref, [ref=att_8], []), |
| , element(attref, [ref=att_10], []), |
| ]), |
| , element(property, [id=prp_15], [ |
| , element(attref, [ref=att_8], []), |
| ]), |
| , element(property, [id=prp_16], [ |
| , element(attref, [ref=att_10], []), |
| ]), |
| , element(property, [id=prp_17], [ |
| , element(attref, [ref=att_11], []), |
| ]), |
| ]), |
| , element(tph, [], [ |
| , element(trans, [src=prp_0, dst=prp_1], []), |
| , element(trans, [src=prp_1, dst=prp_2], []), |
| , element(trans, [src=prp_1, dst=prp_3], []), |
| , element(trans, [src=prp_2, dst=prp_4], []), |
| , element(trans, [src=prp_4, dst=prp_5], []), |
| , element(trans, [src=prp_4, dst=prp_6], []), |
| , element(trans, [src=prp_3, dst=prp_7], []), |
| , element(trans, [src=prp_6, dst=prp_8], []), |
| , element(trans, [src=prp_6, dst=prp_9], []), |
| , element(trans, [src=prp_5, dst=prp_10], []), |
| , element(trans, [src=prp_5, dst=prp_11], []), |
| , element(trans, [src=prp_10, dst=prp_12], []), |
| , element(trans, [src=prp_12, dst=prp_13], []), |
| , element(trans, [src=prp_12, dst=prp_14], []), |
| , element(trans, [src=prp_14, dst=prp_15], []), |
| , element(trans, [src=prp_14, dst=prp_16], []), |
| , element(trans, [src=prp_11, dst=prp_17], []), |
| ]), |
| , element(ard, [], [ |
| , element(dep, [independent=prp_8, dependent=prp_7], []), |
| , element(dep, [independent=prp_9, dependent=prp_7], []), |
| , element(dep, [independent=prp_13, dependent=prp_8], []), |
| , element(dep, [independent=prp_15, dependent=prp_16], []), |
| , element(dep, [independent=prp_16, dependent=prp_9], []), |
| , element(dep, [independent=prp_17, dependent=prp_9], []), |
| ]), |
| ])] |
| |
| </code> |
| |
| |
| ==== BProlog ==== |
| |
| |
| Dokumenty XML po sparsowaniu w BProlog'u posiadają strukturę w postaci termu: |
| |
| //**xml([version, encoding],[ element(...)])**// |
| |
| Argumentami są: |
| * //**[version, encoding]**// - lista zawierająca informacje dotyczące wersji oraz kodowania pliku XML |
| * //**[ element(...)]**// - lista termów o postaci: //**element(Node_Name, [Value], [child_element])**//, gdzie argumentami są: |
| * //**Node_Name**// - nazwa węzła |
| * //**[Value]**// - lista atrybutów węzła |
| * //**[child_element]**// - lista kolejnych elementów - dzieci |
| |
| Poniżej przedstawiono sparsowany plik XML w BProlog: |
| <code prolog> |
| |
| xml( [version="1.0", encoding="utf-8", standalone="no"],[ |
| doctype( hml, system( "hml.dtd" ) ), |
| element( hml,[],[ |
| element( type_set,[],[] ), |
| element( attribute_set,[],[ |
| element( att,[name="Thermostat", id="att_0", value="single", class="ro"],[] ), |
| element( att,[name="Time", id="att_1", value="single", class="ro"],[] ), |
| element( att,[name="Temperature", id="att_2", value="single", class="ro"],[] ), |
| element( att,[name="Date", id="att_3", value="single", class="ro"],[] ), |
| element( att,[name="Hour", id="att_4", value="single", class="ro"],[] ), |
| element( att,[name="season", id="att_5", value="single", class="ro"],[] ), |
| element( att,[name="operation", id="att_6", value="single", class="ro"],[] ), |
| element( att,[name="thermostat_settings", id="att_7", value="single", class="ro"],[] ), |
| element( att,[name="day", id="att_8", value="single", class="ro"],[] ), |
| element( att,[name="month", id="att_9", value="single", class="ro"],[] ), |
| element( att,[name="today", id="att_10", value="single", class="ro"],[] ), |
| element( att,[name="hour", id="att_11", value="single", class="ro"],[] ) |
| ] ), |
| element( property_set,[],[ |
| element( property,[id="prp_0"],[ |
| element( attref,[ref="att_0"],[] ) |
| ] ), |
| element( property,[id="prp_1"],[ |
| element( attref,[ref="att_1"],[] ), |
| element( attref,[ref="att_2"],[] ) |
| ] ), |
| element( property,[id="prp_2"],[ |
| element( attref,[ref="att_1"],[] ) |
| ] ), |
| element( property,[id="prp_3"],[ |
| element( attref,[ref="att_2"],[] ) |
| ] ), |
| element( property,[id="prp_4"],[ |
| element( attref,[ref="att_3"],[] ), |
| element( attref,[ref="att_4"],[] ), |
| element( attref,[ref="att_5"],[] ), |
| element( attref,[ref="att_6"],[] ) |
| ] ), |
| element( property,[id="prp_5"],[ |
| element( attref,[ref="att_3"],[] ), |
| element( attref,[ref="att_4"],[] ) |
| ] ), |
| element( property,[id="prp_6"],[ |
| element( attref,[ref="att_5"],[] ), |
| element( attref,[ref="att_6"],[] ) |
| ] ), |
| element( property,[id="prp_7"],[ |
| element( attref,[ref="att_7"],[] ) |
| ] ), |
| element( property,[id="prp_8"],[ |
| element( attref,[ref="att_5"],[] ) |
| ] ), |
| element( property,[id="prp_9"],[ |
| element( attref,[ref="att_6"],[] ) |
| ] ), |
| element( property,[id="prp_10"],[ |
| element( attref,[ref="att_3"],[] ) |
| ] ), |
| element( property,[id="prp_11"],[ |
| element( attref,[ref="att_4"],[] ) |
| ] ), |
| element( property,[id="prp_12"],[ |
| element( attref,[ref="att_8"],[] ), |
| element( attref,[ref="att_9"],[] ), |
| element( attref,[ref="att_10"],[] ) |
| ] ), |
| element( property,[id="prp_13"],[ |
| element( attref,[ref="att_9"],[] ) |
| ] ), |
| element( property,[id="prp_14"],[ |
| element( attref,[ref="att_8"],[] ), |
| element( attref,[ref="att_10"],[] ) |
| ] ), |
| element( property,[id="prp_15"],[ |
| element( attref,[ref="att_8"],[] ) |
| ] ), |
| element( property,[id="prp_16"],[ |
| element( attref,[ref="att_10"],[] ) |
| ] ), |
| element( property,[id="prp_17"],[ |
| element( attref,[ref="att_11"],[] ) |
| ] ) |
| ] ), |
| element( tph,[],[ |
| element( trans,[src="prp_0", dst="prp_1"],[] ), |
| element( trans,[src="prp_1", dst="prp_2"],[] ), |
| element( trans,[src="prp_1", dst="prp_3"],[] ), |
| element( trans,[src="prp_2", dst="prp_4"],[] ), |
| element( trans,[src="prp_4", dst="prp_5"],[] ), |
| element( trans,[src="prp_4", dst="prp_6"],[] ), |
| element( trans,[src="prp_3", dst="prp_7"],[] ), |
| element( trans,[src="prp_6", dst="prp_8"],[] ), |
| element( trans,[src="prp_6", dst="prp_9"],[] ), |
| element( trans,[src="prp_5", dst="prp_10"],[] ), |
| element( trans,[src="prp_5", dst="prp_11"],[] ), |
| element( trans,[src="prp_10", dst="prp_12"],[] ), |
| element( trans,[src="prp_12", dst="prp_13"],[] ), |
| element( trans,[src="prp_12", dst="prp_14"],[] ), |
| element( trans,[src="prp_14", dst="prp_15"],[] ), |
| element( trans,[src="prp_14", dst="prp_16"],[] ), |
| element( trans,[src="prp_11", dst="prp_17"],[] ) |
| ] ), |
| element( ard,[],[ |
| element( dep,[independent="prp_8", dependent="prp_7"],[] ), |
| element( dep,[independent="prp_9", dependent="prp_7"],[] ), |
| element( dep,[independent="prp_13", dependent="prp_8"],[] ), |
| element( dep,[independent="prp_15", dependent="prp_16"],[] ), |
| element( dep,[independent="prp_16", dependent="prp_9"],[] ), |
| element( dep,[independent="prp_17", dependent="prp_9"],[] ) |
| ] ) |
| ] ) |
| ] ). |
| </code> |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| ==== JIProlog ==== |
| Dokument XML po sparsowaniu w JIProlog jest przedstawiony w postaci zagnieżdżonych termów zaczynając od //xml_document// i idąc wgłąb //xml_element//, //xml_attribute// oraz //xml_text//. |
| |
| Charakterystyczne dla postaci prologowej są: |
| * //**xml_document([ [version = Version, encoding = Encoding], DocType], Root).**//, gdzie argumentami są: |
| * //**[ [version = Version, encoding = Encoding], DocType]**// - lista składająca się z listy zawierającej informacje o kodowaniu i wersji pliku XML oraz z informacji o typie dokumentu |
| * //**Root**// - korzeń dokumentu XML |
| * //**xml_element(Name, Attributes, Children)**// - kolejne elementy pliku XML. Argumentami są: |
| * //**Name**// - nazwa węzła |
| * //**Attributes**// - lista atrybutów zawierająca termy postaci: //**xml_attribute(Name, Value)**//, gdzie argumentami są: |
| * //**Name**// - nazwa atrybutu |
| * //**Value**// - wartość atrybutu |
| * //**Children**// - lista kolejnych dzieci węzła, zawierająca ponownie termy //**xml_element(Name, Attributes, Children)**// oraz //**xml_text(Content)**// - tekst węzła |
| |
| Poniżej przedstawiono sparsowany plik XML w JIProlog: |
| <code prolog> |
| X=xml_document([version = 1.0, encoding = UTF-8], [], |
| xml_element(hml, [], [xml_text(), |
| xml_element(type_set, [], [xml_text()]), xml_text(), |
| xml_element(attribute_set, [], [xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_0), |
| xml_attribute(name, Thermostat), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_1), |
| xml_attribute(name, Time), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_2), |
| xml_attribute(name, Temperature), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_3), |
| xml_attribute(name, Date), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_4), |
| xml_attribute(name, Hour), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_5), |
| xml_attribute(name, season), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_6), |
| xml_attribute(name, operation), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_7), |
| xml_attribute(name, thermostat_settings), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_8), |
| xml_attribute(name, day), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_9), |
| xml_attribute(name, month), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_10), |
| xml_attribute(name, today), |
| xml_attribute(value, single)], |
| []), xml_text(), |
| xml_element(att, [ |
| xml_attribute(class, ro), |
| xml_attribute(id, att_11), |
| xml_attribute(name, hour), |
| xml_attribute(value, single)], |
| []), xml_text() |
| ]), xml_text(), |
| xml_element(property_set, [], [xml_text(), |
| xml_element(property, [xml_attribute(id, prp_0)],[xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_0)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_1)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_1)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_2)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_2)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_1)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_3)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_2)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_4)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_3)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_4)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_5)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_6)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_5)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_3)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_4)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_6)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_5)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_6)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_7)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_7)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_8)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_5)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_9)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_6)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_10)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_3)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_11)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_4)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_12)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_8)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_9)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_10)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_13)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_9)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_14)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_8)], []), xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_10)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_15)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_8)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_16)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_10)], []), xml_text() |
| ]), xml_text(), |
| xml_element(property, [xml_attribute(id, prp_17)], [xml_text(), |
| xml_element(attref, [xml_attribute(ref, att_11)], []), xml_text() |
| ]), xml_text() |
| ]), xml_text(), |
| xml_element(tph, [], [xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_1), xml_attribute(src, prp_0)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_2), xml_attribute(src, prp_1)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_3), xml_attribute(src, prp_1)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_4), xml_attribute(src, prp_2)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_5), xml_attribute(src, prp_4)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_6), xml_attribute(src, prp_4)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_7), xml_attribute(src, prp_3)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_8), xml_attribute(src, prp_6)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_9), xml_attribute(src, prp_6)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_10), xml_attribute(src, prp_5)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_11), xml_attribute(src, prp_5)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_12), xml_attribute(src, prp_10)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_13), xml_attribute(src, prp_12)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_14), xml_attribute(src, prp_12)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_15), xml_attribute(src, prp_14)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_16), xml_attribute(src, prp_14)], []), xml_text(), |
| xml_element(trans, [xml_attribute(dst, prp_17), xml_attribute(src, prp_11)], []), xml_text() |
| ]), xml_text(), |
| xml_element(ard, [], [xml_text(), |
| xml_element(dep, [xml_attribute(dependent, prp_7), xml_attribute(independent, prp_8)], []), xml_text(), |
| xml_element(dep, [xml_attribute(dependent, prp_7), xml_attribute(independent, prp_9)], []), xml_text(), |
| xml_element(dep, [xml_attribute(dependent, prp_8), xml_attribute(independent, prp_13)], []), xml_text(), |
| xml_element(dep, [xml_attribute(dependent, prp_16), xml_attribute(independent, prp_15)], []), xml_text(), |
| xml_element(dep, [xml_attribute(dependent, prp_9), xml_attribute(independent, prp_16)], []), xml_text(), |
| xml_element(dep, [xml_attribute(dependent, prp_9), xml_attribute(independent, prp_17)], []), xml_text() |
| ]) |
| ])) |
| </code> |
| |
| |
| |
| |
| |
| |
| |
| |
===== Implementacja API w SWI-Prolog ===== | ===== Implementacja API w SWI-Prolog ===== |
| Ogólnodostępne wersje prologu nie posiadają mechanizmów do generowania dokumentów XML-DOM. Jedynie JIProlog dysponuje takimi możliwościami. Predykaty pozwalające na budowę dokumentu XML w JIProlog zostały omówione w sekcji ([[pl:miw:miw08_prolog_xml#jiprolog|JIprolog]]) W związku z tym postanowiono zaimplementować własne API do budowania plików XML. Jako wersję prologu przyjęto SWI-Prolog. Zaimplementowano następujące główne predykaty: |
| - //**create_root/2**// - tworzenie korzenia dokumentu XML |
| - //**app_child/4**// - dodawanie dzieci |
| - //**add_attribute/3**// - dodawanie atrybutów |
| |
| Plik zawierający pełne API dostępny jest do pobrania {{:pl:miw:miw08_prolog_xml:xml_api.pl|tutaj}} |
| |
| W przyszłości funkcjonalności API można dalej rozszerzać, np. o predykaty umożliwiające usuwanie dzieci, usuwanie atrybutów, czy też zmianę nazwy atrybutu bądź jego wartości. |
| |
| |
| |
| |
| |
| |
===== Przykład użycia API ===== | ===== Przykład użycia API ===== |
| W celu prezentacji działania API przygotowano przykład, w którym pokazane zostało generowanie dokumentu XML (budowanie dokumentu podobnego do pliku pochodzącego z systemu VARDA). |
| |
| Budowanie dokumentu XML rozpoczyna się od stworzenia korzenia. |
| |
| ==== Tworzenie korzenia ==== |
| Korzen dokumentu xml tworzymy wykorzystując predykat: |
| <code prolog> |
| create_root(Name,ID_name). |
| </code> |
| Jako parametry podajemy kolejno: |
| * nazwę korzenia |
| * prefiks id, np. podając **cd**, zostanie stworzony **id=cd_0** gdzie **0** będzie kolejno nadawaną liczbą, startując od zera. |
| |
| Po użyciu tego predykatu pojawi się nam główny element struktury prologowej stanowiący korzeń dokumentu xml. |
| |
| Przykład: |
| <code prolog> |
| ?- create_root(hml,hml). |
| |
| Yes |
| ?- listing(element). |
| |
| :- dynamic element/3. |
| |
| element(hml, [id=hml_0], []). |
| </code> |
| |
| Po stworzeniu korzenia dokumentu XML przechodzimy do dodawania kolejnych dzieci. |
| |
| |
| |
| |
| |
| |
| |
| ==== Dodawanie dzieci ==== |
| Dodawanie dzieci do korzenia dokumentu lub do istniejących rodziców wykonuje się za pomocą predykatu: |
| <code prolog> |
| app_child(Parent,P_id,Child,ChildIdName). |
| </code> |
| W predykacie tym jako argumenty podajemy kolejno: |
| * Nazwę rodzica |
| * Id rodzica - jeśli istnieje wiele elementów o tej samej nazwie, podajemy id rodzica, jeśli nie jest ważne do którego rodzica chcemy dodać dziecko wpisujemy "_" (dziecko zostanie dodane do pierwszego istniejącego rodzica) |
| |
| :!::!:**//UWAGA//**:!::!: |
| |
| Kiedy podajemy **id** rodzica, do którego chcemy przypisać dziecko, podajemy pełny tekst, np. **//id=prp_1//**. |
| * Nazwa dziecka |
| * prefiks id dziecka; Podając **ala** zostanie stworzony prefiks **ala_**, któremu automatycznie zostanie przydzielona kolejna liczba, np. **ala_1**. |
| |
| Dodanie dziecka o nazwie **//type_set//** i id **//typ_s//** do rodzica **//hml//** (korzeń) przedstawia poniższy kod: |
| <code prolog> |
| ?- app_child(hml,_,type_set,typ_s). |
| </code> |
| Powstaje następująca struktura, korzeń **//hml//** ma na liście dziecko **//type_set//** z id o podanym prefiksie i przydzielonym numerze. |
| <code prolog> |
| element(hml, [id=hml_0], [element(type_set, [id=typ_s_0], [])]). |
| </code> |
| |
| W podobny sposób dodajemy dzieci: |
| * attribute_set <code prolog> ?- app_child(hml,_,attribute_set,att_s). </code> |
| * property_set <code prolog> ?- app_child(hml,_,property_set,prp_s). </code> |
| * tph <code prolog> ?- app_child(hml,_,tph,tph). </code> |
| * ard <code prolog> ?- app_child(hml,_,ard,ard). </code> |
| |
| W celu dodania za jednym razem większej ilości dzieci używamy predykatu pochodnego: |
| <code prolog> |
| app_child(Parent,P_id,Child,ChildIdName,How_many). |
| </code> |
| Dodatkowym argumentem jest //**How_many**//, który oznacza ilość dodawanych dzieci. |
| |
| Jest to przydatne np, podczas dodawania wielu dzieci **//att//** do rodzica **//attribute_set//**. |
| Po użyciu predykatu: |
| <code prolog> |
| app_child(attribute_set,_,att,att,12). |
| </code> |
| zostanie dodanych dwanaście dzieci do rodzica **//attribute_set//**. |
| |
| Podobnie dodajemy: |
| * dzieci **//property//** do rodzica **//property_set//** <code prolog> ?- app_child(property_set,_,property,prp,18)</code> |
| * dzieci **//trans//** do rodzica **//tph//** <code prolog> ?- app_child(tph,_,trans,tr,17).</code> |
| * dzieci **//dep//** do rodzica **//ard//** <code prolog> ?- ?- app_child(ard,_,dep,dp,6).</code> |
| |
| Następnie pozostaje tylko dodanie odpowiednich dzieci **//attref//** do odpowiednich rodziców **//property//**. |
| Tu ponownie wykorzystujemy wyżej wymieniany predykat, ale już z podaniem ID rodzica. Przykładowo, po wpisaniu: |
| <code prolog> ?- app_child(property,id=prp_1,attref,att_r,2)</code> |
| dodane zostaną dwoje dzieci **//attref//** z id o prefiksie //**att_r_**// do rodzica **//property//** o id **//id=prp_1//**. |
| |
| ---- |
| :!::!:**//UWAGA//**:!::!: |
| |
| Kiedy podajemy **id** rodzica, do którego chcemy przypisać dziecko, podajemy pełny tekst, np. **//id=prp_1//**. |
| ---- |
| |
| |
| W ten sposób stworzono cały szkielet dokumentu XML o zadanym korzeniu oraz zadanych dzieciach. Każdy element posiada własne, unikalne id. Ostatnią rzeczą będzie dodawanie odpowiednich atrybutów. |
| |
| |
| |
| ==== Dodawanie atrybutów ==== |
| Atrybuty do wybranego elementu dodaje się przy użyciu predykatu, |
| <code prolog> |
| add_attribute(Parent,P_id,Attr). |
| </code> |
| gdzie jako argument podajemy kolejno: |
| * nazwę elementu, do którego chcemy dodać atrybut |
| * id elementu, do którego chcemy dodać atrybut |
| * atrybut (//nazwa=wartość//), który chcemy dodać |
| |
| ---- |
| |
| :!::!://**UWAGA**//:!::!: |
| |
| Kiedy podajemy **id** elementu, do którego chcemy dodać atrybut, podajemy pełny tekst, np. **//id=att_0//**. |
| |
| Podobnie jest w przypadku podawania atrybutu. Podajemy pełny tekst zawierający znak **//"="//** , np. **//name=thermostat//** |
| ---- |
| |
| Przykładowo użycie |
| <code prolog> |
| ?- add_attribute(att,id=att_0,name=thermostat). |
| </code> |
| spowoduje dodanie atrybutu **//name=thermostat//** do elementu **//att//** o id **//id=att_0//**. |
| |
| W ten sam sposób możemy dodać każdy atrybut do każdego istniejącego elementu w "prologowej" strukturze XML. |
| |
| |
| |
| |
| ==== Tworzenie pliku xml ==== |
| |
| Plik XML tworzymy przy użyciu predykatu |
| <code prolog> |
| prolog2xml(File). |
| </code> |
| Po wpisaniu: |
| <code prolog> |
| ?- prolog2xml('test.xml'). |
| </code> |
| zostanie utworzony plik XML o nazwie test. |
| |
| Możemy też skorzystać z predykatu |
| <code prolog> |
| save(File). |
| </code> |
| który zapisze w podanym pliku aktualną "prologową" strukturę XML oraz aktualny stan nadanych id, np. |
| <code prolog> |
| save('wiedza.pl'). |
| </code> |
| |
| Przykład dokumentu XML wygenerowanego z użyciem API znajduje się {{:pl:miw:test.xml|tutaj}}. |
| |
====== Projekt ====== | ====== Projekt ====== |