ChickenLipsRfun2eat
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Hallo zusammen! Ich versuche gerade für mein eigenes Projekt und möglichst mit den Standards in C++ ein Datenmodell zusammenzuschustern. Ziel des ganzen ist die Verwaltung von URLs. Aufbau soll folgender sein:string URL, string DESCRIPTION, int ORDER_NUM | //Möglichkeiten:
std::map< string URL, std::map< string desc, int num> >
//oder
std::tuple<...>
|
Als dritte Möglichkeit wären drei Listen eine Idee. Meine Frage dazu: Welches davon lässt sich im Endeffekt einfacher handhaben? Die ORDER_NUM 1 soll immer das "primäre Ziel" ergeben und natürlich einstellbar sein. Ich brauche ebenfalls eine Sortierbarkeit nach Alphabet bei der stringList URL. Oder gibt es da eine viel einfachere Lösung, die ich auf Grund Baum<->Wald nicht sehe? Vielen Dank im Voraus!
|
rklm
Projektleitung
Anmeldungsdatum: 16. Oktober 2011
Beiträge: 12801
|
ChickenLipsRfun2eat schrieb:
Ich versuche gerade für mein eigenes Projekt und möglichst mit den Standards in C++ ein Datenmodell zusammenzuschustern.
Es gehört aber schon dazu, dass man auch eigene Datentypen definiert. Sonst gäbe es ja Deine Anwendung bereits "von der Stange" in der Standarbibliothek.
| //Möglichkeiten:
std::map< string URL, std::map< string desc, int num> >
//oder
std::tuple<...>
|
Die geschachtelte map ergibt keinen Sinn: Du willst ja nur eine Beschreibung und eine Nummer pro URL speichern. Oder?
Als dritte Möglichkeit wären drei Listen eine Idee.
Ganz schlecht: Du musst drei Datenstrukturen so pflegen, dass sie immer synchron sind. Das ist viel zu fehleranfällig und auch schwer zu verstehen.
Meine Frage dazu: Welches davon lässt sich im Endeffekt einfacher handhaben? Die ORDER_NUM 1 soll immer das "primäre Ziel" ergeben und natürlich einstellbar sein. Ich brauche ebenfalls eine Sortierbarkeit nach Alphabet bei der stringList URL. Oder gibt es da eine viel einfachere Lösung, die ich auf Grund Baum<->Wald nicht sehe?
Du müsstest mal schreiben, wie Du zugreifen willst. Sortierung nach URL hast Du ja schon erwähnt. Welche Zugriffsmuster gibt es noch? So würde ich erst mal sagen: führe einen Datentyp ein, der alle drei Dinge zusammenfasst. Dann kannst Du Objekte dieses Typs in welchen Container auch immer packen.
|
ChickenLipsRfun2eat
(Themenstarter)
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Da hast Du Recht. Die drei Listen würden eine eigene Klasse erfordern, um die Änderungen, Eintragungen, etc. fehlerfrei hinzubekommen. Das einfachste wäre ein struct zusammengeführt in einer Liste. Würde aber ebenso bedeuten, dass ich es recht umständlich sortieren müsste, da ich jedesmal einen loop über alle items brauche, um nach URL oder NUM zu sortieren. | struct bla {
bla() : url(""), desc("") num(0) {}
string url;
string desc;
int num;
};
std::list<bla> blub; //Wäre die aufm heap schneller/sinnvoller? also std::list<bla> *blub; ??
|
würde zur Bequemlichkeit aber einfacher als Klasse sein mit methoden für add, remove, clear, count,...usw. Daher dachte ich an Listen. Sonst müsste ich für die Reihenfolge ja jedesmal einen neuen loop starten, um die nächste freie Nummer zu ermitteln. In einer Klasse könnte ich die per m_countnum ja in- oder dekrementieren (heißt das so auf deutsch?^^)
|
rklm
Projektleitung
Anmeldungsdatum: 16. Oktober 2011
Beiträge: 12801
|
ChickenLipsRfun2eat schrieb: Da hast Du Recht. Die drei Listen würden eine eigene Klasse erfordern, um die Änderungen, Eintragungen, etc. fehlerfrei hinzubekommen. Das einfachste wäre ein struct zusammengeführt in einer Liste.
Genau.
Würde aber ebenso bedeuten, dass ich es recht umständlich sortieren müsste, da ich jedesmal einen loop über alle items brauche, um nach URL oder NUM zu sortieren.
Nö. Du kannst ja passende Indexe (maps) anlegen. Das ganze packst Du dann vermutlich am besten in eine Klasse, so dass man das von außen entsprechend manipulieren kann, ohne dass die Datenstruktur intern inkonsistent wird.
würde zur Bequemlichkeit aber einfacher als Klasse sein mit methoden für add, remove, clear, count,...usw. Daher dachte ich an Listen.
Drei Listen in lock step zu sortieren ist viel ekliger als eine Liste zu sortieren.
Sonst müsste ich für die Reihenfolge ja jedesmal einen neuen loop starten, um die nächste freie Nummer zu ermitteln. In einer Klasse könnte ich die per m_countnum ja in- oder dekrementieren (heißt das so auf deutsch?^^)
Noch mal: Was sind denn die Zugriffsmuster? Ohne, dass wir wissen, was Du vorhast, können wir Dir nicht gut helfen.
|
ChickenLipsRfun2eat
(Themenstarter)
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Entschuldigung. Ich benötige Abfragen nach der Reihenfolge und nach Alphabet. 1
2
3
4
5
6
7
8
9
10
11
12 | ...
/*
Wenn die url unbekannt ist: nächste freie Nummer wird belegt, bei prefered=true "Haupturl" setzen, dann wäre num=1.
Wenn diese (num=1) schon belegt ist, dann muss alles eins nach hinten verschoben werden
Existiert die Url schon, wird lediglich geprüft, ob sie an Pos1 rücken soll (prefered) oder nicht.
*/
void addUrl(string url, string descr="", bool prefered=false);
void removeUrl(string url); //nummern müssen angepasst werden, damit keine "Lücken" entstehen
void removeUrl(int num); //dito, nach Nummer
std::list<string> getUrls(bool alphabetic=false); //true=alphabetische Reihenfolge, false=nach num
...
|
Einfach ausgedrückt versuche ich damit eine zweidimensionale Tabelle zu erstellen, die ich einmal nach string URL sortieren kann und einmal nach NUM. Danke Dir für deine Hilfe!
|
Lysander
Anmeldungsdatum: 30. Juli 2008
Beiträge: 2669
Wohnort: Hamburg
|
Ich kapiere den Anwendungsfall noch nicht wirklich! Was soll diese "NUM" aussagen? Was ist *eindeutig* und was kann doppelt vorkommen? Wieso gibt es überhaupt einen zusätzlichen (?) numerischen Schlüssel? Ist das dann überhaupt ein Teil dieses Datums oder nur ein künstlicher Surrogate-Schlüssel? Ich brauche da definitiv mehr Infos, um sinnvolles zum eigentlichen Problem vorschlagen zu können! Aber so viel am Rande: Boolesche Flags als Parameter sind übrigens idR. nicht so dolle - vermeide Sie, indem Du sinnvoll benannte Namen für Funktionen (oder Methoden) wählst. Ich persönlich empfinde Default-Parameter oft auch als nicht so gut. Ein leerer String ist bspw. afair keine gültige URL; ergo keine gute Idee, so etwas zuzulassen! Dies kann man aber auch vermeiden, indem man das API so umbaut, dass der Datentyp übergeben wird und nicht eine "lose" Sammlung von Parametern! Die Constraints können dann bereits beim Erzeugen des Datentyp-Objekts geprüft werden, so dass fehlerhafte Daten bereits dort erkannt und ggf. behandelt werden können.
|
ChickenLipsRfun2eat
(Themenstarter)
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Hallo und danke für deinen Beitrag! Im Prinzip ist das nichts anderes, als eine Sammlung von Links. Diese möchte ich in einer vom Anwender (also mir) festgelegten Reihenfolge darstellen können (NUM), wobei die Haupturl immer die Nummer 1 haben soll und natürlich änderbar ist.
Als parallel-Beispiel: Hauptemail-Adresse, Nebenadressen (wobei bei denen die Reihenfolge egal wäre) Das mit den boolschen flags kann ich nachvollziehen, aber wie würde es denn besser sein? Einen zweiten Funktionsaufruf um eine (neue) URL als "1" zu setzen wollte ich an sich vermeiden. Geht natürlich auch dann eine setPref(URL)-Methode einzubauen. Das mit dem Übergeben des Datentyps ist sinnvoll. Merk ich mir. Danke! Nebenbei bemerkt: diese code-Zeilen hier sind ja nur zur Veranschaulichung. Den echten Code gibt es noch nicht, da ich ja erstmal überlege, wie ich sowas am effektivsten umsetzen kann.
|
Lysander
Anmeldungsdatum: 30. Juli 2008
Beiträge: 2669
Wohnort: Hamburg
|
ChickenLipsRfun2eat schrieb: Im Prinzip ist das nichts anderes, als eine Sammlung von Links. Diese möchte ich in einer vom Anwender (also mir) festgelegten Reihenfolge darstellen können (NUM), wobei die Haupturl immer die Nummer 1 haben soll und natürlich änderbar ist.
Das ist schon einmal interessant... worin unterscheiden sich denn Haupt- und Neben-URLs?
Als parallel-Beispiel: Hauptemail-Adresse, Nebenadressen (wobei bei denen die Reihenfolge egal wäre)
Ah... ok.
Das mit den boolschen flags kann ich nachvollziehen, aber wie würde es denn besser sein? Einen zweiten Funktionsaufruf um eine (neue) URL als "1" zu setzen wollte ich an sich vermeiden. Geht natürlich auch dann eine setPref(URL)-Methode einzubauen.
In der Tat sind das *zwei* semantisch verschiedene Dinge, die Du tun willst. Also biete im (öffentlichen) API auch *zwei* Funktionen dafür an! Ich gebe Dir mal ein Beispiel, welches das schön verdeutlicht (in Python und ungetestet, aber auch ohne Python Kenntnisse verständlich):
| def add(a, b, adding=True):
return a + b if adding else a - b
add(3, 2)
> 5
add(3, 2, False)
> 1
|
Niemand würde so ein API wollen; zumal man sich immer daran erinnern muss, welcher Wahrheitswert, welches Verhalten steuert. Um mal ein negatives Beispiel aus der Realität zu geben: MS hat in seinem ollen (und schlimmen") MFC-Framework ein Art automatisches Mapping zwischen GUI- und zugehörigen Datenobjekten eingebaut. Stell Dir eine Textbox und einen String vor. Ich kann nun in beide Objekte einen Text schreiben, je nach dem, ob ich über die GUI etwas eingegeben habe und das weiter verarbeiten will oder den Inhalt programmatisch vorgeben möchte und dieser in der GUI gleich angezeigt werden soll. Um beide Objekte zu synchronisieren gibt es die CWnd::UpdateData(BOOL bSaveAndValidate) -Methode. Das boolesche Flag bestimmt, welches Objekt als Quelle und welches als Ziel des "Kopiervorgangs" angesehen wird. Ist das Flag TRUE (der Default), so werden die Daten aus dem GUI-Element in das Modell-Element kopiert. Bei FALSE ist es anders herum. Ich hoffe Du kannst Dir denken, wie verwirrend das ist und das man *jedes* Mal darüber nachdenken muss, wie man das Flag setzen muss... bei google wird es selten so viele Treffer geben bezüglich eines Programmierproblems 😈
Nebenbei bemerkt: diese code-Zeilen hier sind ja nur zur Veranschaulichung. Den echten Code gibt es noch nicht, da ich ja erstmal überlege, wie ich sowas am effektivsten umsetzen kann.
Ist mir schon klar, aber auch Pseudo-Code oder simples aufschreiben der Signaturen als Blaupause bringt ja oft Klarheit rein und hilft, die eigenen Gedanken schon einmal zu formalisieren - und dann kann ggf. man auch schon Probleme erahnen 😉 Mir ist tatsächlich immer noch nicht zu 100% klar, was das mit der Nummer auf sich hat. Kannst Du mal ein kleines textuelles Beispiel geben? Also einfach mal als CSV o.ä. notieren, was für Daten zusammengehörig auftreten können und wie die dann ggf. angezeigt werden sollen? Ich glaube ich ahne so langsam etwas, will aber auf Nummer sicher gehen, bevor ich eine falsche Richtung einschlage...
|
ChickenLipsRfun2eat
(Themenstarter)
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Beispiele: Bleiben wir bei den Email-Adressen, da das das Verhalten der Nummern am ehesten erklärt. | #Beispielliste:
#Beschreibungen lasse ich leer, sollte selbsterklärend sein ;)
ich@anbieter.de; ;1
ich@anbieter.de; ;2
zwei@anbieter.de; ;3
drei@anbieter2.de; ;4
...
|
Jetzt ändert sich meine Hauptadresse auf bla@anbieter.de:
| bla@anbieter.de; ;1
ich@anbieter.de; ;2
zwei@anbieter.de; ;3
drei@anbieter2.de; ;4
bla@anbieter.de; ;5
...
|
Nun wechsle ich wieder zu ich@anbieter.de als Hauptadresse:
| ich@anbieter.de; ;1
ich@anbieter.de; ;2
zwei@anbieter.de; ;3
drei@anbieter2.de; ;4
bla@anbieter.de; ;5
...
|
Die weiteren Adressen bleiben in der Reihenfolge unberührt, das Ziel der "1" wäre immer die Hauptadresse darzustellen. Theoretisch könnte ich diese aber in einer eigenen Klasse auch separat als struct speichern. Mein Ursprungsgedanke war ja es nicht in ner extra Klasse zu speichern, sondern einen Datentyp dafür zu basteln, bzw. zu finden. Also in einer Klasse würde ich wahrscheinlich dazu tendieren die Nummer wegzulassen und die Haupturl zu speichern.
|
rklm
Projektleitung
Anmeldungsdatum: 16. Oktober 2011
Beiträge: 12801
|
Wozu brauchst Du denn den Zugriff per URL? Und: gibt es irgendein Gruppierungsmerkmal, so dass Du eine Hauptadresse pro Gruppe und mehrere Nebenadressen hast?
|
ChickenLipsRfun2eat
(Themenstarter)
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Nein, leider kein Gruppierungsmerkmal. Die URLS sind frei wählbar. Als Beispiel könnte eine Liste so aussehen:
| NUM URL DESC
1 www.ubuntuusers.de uu
2 www.ubuntuusers.de uu
3 /home/ich/datei.pdf Infos über lalelu
4 /usr/src/Quelle Quelle von Programm x
5 www.google.de Suchmaschine
6 192.168.1.1 Router
...
|
Und die Urls brauche ich natürlich, um ihnen zu folgen, bzw. letzten endes hyperlinks zu erstellen. (edit: nummern korrigiert)
|
Lysander
Anmeldungsdatum: 30. Juli 2008
Beiträge: 2669
Wohnort: Hamburg
|
Ich würde die Gruppen *nicht* mit dem Basisdatenmodell mischen. Letzteres besteht imho lediglich aus einer URL und einer Beschreibung. Da eine URL per se eindeutig ist, ist das dann auch ein wunderbarer Kandidat für einen Schlüssel, um aus anderen Containern auf ein bestimmtes Exemplar zu verweisen. Gruppen kannst Du nun eigenständig modellieren. Die Frage für mich wäre, ob es nur immer eine Haupt-URL pro Gruppe gibt und eine beliebige Anzahl an weiteren URLs pro Gruppe oder ob es sich eher um eine baumartige Struktur handelt. Für ersteren Fall könntest Du eine Klasse bauen, die eben einen "Getter" für die Haupt-URL anbietet und ansonsten einen oder zwei (lesende) Iteratoren, um auf die restlichen oder alle URLs zuzugreifen. Intern kannst Du dann z.B. eine std::unordered_map nutzen, um die URL-artigen Datenobjekte auf ihren Schlüssel (die URL an sich) abzubilden. Aber die Interna sollte man ja eh "verstecken"; daher auch das API mit Iteratoren. Dazu kommen natürlich noch "Setter"- bzw. "Adder"-Methoden oder auch etwas zum Entfernen aus Gruppen. Dazu käme noch eine Methode zum Setzen der Haupt-URL. Wie Du dann Gruppen organisierst, kannst Du dann ja immer noch entscheiden. So wirklich klar ist mir das big picture aber immer noch nicht! Kannst Du nicht ein paar Worte drum herum verlieren, *wozu* Du diese URLs derartig organisieren willst? Das ist ja alles kein Selbstzweck, sondern dient ja bestimmt irgend einem Ziel. Und wenn wir das kennen, dann kann man sicherlich auch besser abschätzen, wie man das sinnvoll umsetzen kann.
|
ChickenLipsRfun2eat
(Themenstarter)
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Die Frage für mich wäre, ob es nur immer eine Haupt-URL pro Gruppe gibt
ja
Kannst Du nicht ein paar Worte drum herum verlieren, *wozu* ...
ja ☺ Also letzten Endes ist das nur ein Teil einer Informationssammlung. Ich sammle über mich quasi diverse Informationen, ähnlich einer VCF-Datei oder so...als Basis. Dazu kann ich halt jede Menge Notizen dazupacken, wie z.B. URLs, Pfadangaben im System (dafür die Klasse), kleine Textdateien, Bilder, uvm. Sinn des Ganzen ist gerade eigentlich nur das Programmieren an sich. Ich möchte mich quasi selbst verwalten und das ganze ausbaufähig haben. Da die meisten Informationen, Notizen, Bilder, etc. natürlich in Form von Pfadangaben/URLs verfügbar sind, möchte ich diese natürlich strukturieren können und auch die Reihenfolge festlegen. Den Teil mit der Haupturl verwende ich u.a. als "Index" für ähnliche Inhalte. Also als Beispiel ein Bild von meinem PC, die URL zu www.ubuntuusers.de, die Telefonnummer von der Seelsorge, wenn ich nicht weiter weiß und das Bild von meiner Freundin, damit ich weiß, dass ich nicht den ganzen Abend am PC sitzen soll... Dafür brauche ich als "kleinstes" Datenmodell eben eine URL-Liste, deren Reihenfolge ich frei bestimmen kann, mit eben einer Haupturl. Diese könnte natürlich auch eine Link-Gruppe ergeben wie
| 1 www.ubuntuusers.de Startseite
2 www.ubuntuusers.de Startseite
3 https://forum.ubuntuusers.de/egosearch/ Das meist vermisste Teil des heutigen Tages
4 https://forum.ubuntuusers.de/topic/bla Informationen zu bla
...
|
|
rklm
Projektleitung
Anmeldungsdatum: 16. Oktober 2011
Beiträge: 12801
|
Lysander schrieb: Ich würde die Gruppen *nicht* mit dem Basisdatenmodell mischen.
Was genau das Basisdatenmodell sein müsste, ist mir noch nicht klar. Ich habe mich halt gefragt, ob es nur eine einzige Haupt-URL gibt oder doch mehrere (also eine pro Gruppe, was auch immer eine Gruppe ist). Das würde schon einen Unterschied machen, wie man die Struktur aufsetzt.
So wirklich klar ist mir das big picture aber immer noch nicht!
Eben. Deshalb halte ich mich auch mit weiteren Vorschlägen zurück.
Kannst Du nicht ein paar Worte drum herum verlieren, *wozu* Du diese URLs derartig organisieren willst? Das ist ja alles kein Selbstzweck, sondern dient ja bestimmt irgend einem Ziel. Und wenn wir das kennen, dann kann man sicherlich auch besser abschätzen, wie man das sinnvoll umsetzen kann.
Genau. Es wäre vielleicht mal eine sinnvolle Übung für ChickenLipsRfun2eat einen abstrakten Datentypen zu definieren, also die Operationen aufzuschreiben und die erwarteten Ergebnisse festzulegen.
|
ChickenLipsRfun2eat
(Themenstarter)
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Hallo ihr beiden! Abstrakte Datentypen beschreiben ist mal ne Aufgabe 😀 Ich habe mal grob die Klasse zusammengeschrieben, wie sie aussehen könnte. Dabei könnte man allerdings das std::list<struct> durch eine std::map ersetzen, denke ich mal.
Anstatt des "NUM" zur Sortierung habe ich nun die Haupt-Url als Kopie abgelegt (könnte eine Referenz sinnvoller sein). Der Code ist ungetestet! Ich werde mich daran machen eine Beispiel-Umgebung zu erstellen, in der ich die Klasse benutze. .h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 | //Dieses Element dient zur reinen Datenablage
struct urlListItem {
std::string m_url;
std::string m_desc;
};
class urlList
{
public:
urlList();
std::list<urlListItem> getItemList(); //gibt die komplette Liste der Elemente aus: In diesem Fall ist die Haupt-Url nicht klar ersichtlich!
std::list<std::string> getUrlList(); //Gesamtliste: nur URLs
std::list<std::string> getDescriptionList(); //Gesamtliste: nur Beschreibungen (macht keinen Sinn, aber ich habs mal reingeschrieben^^)
std::map<std::string, std::string> asMap(); //Da ich merkte, dass man mit einer map vllt sinnvoller weiterarbeiten kann wird hier die std::list<struct> als std::map zurückgegeben
void addUrl(std::string url, std::string description=""); //hinzufügen einer beliebigen URL mit oder ohne Beschreibung. Erstellt ein urlListItem für die Liste und fügt dieses am Ende ein (push_back)
void addUrl(urlListItem item);
void removeUrl(std::string url); //Sucht und entfernt das struct mit der angegebenen url
void removeUrl(urlListItem item); //direkte Entfernung eines bekannten struct
void changeDescription(std::string url, std::string desc);
std::string getDescription(std::string url);
void setPrefered(std::string url); //Sucht das betroffene struct und speichert eine Kopie als _pref
void setPrefered(urlListItem item); //Überprüft, ob das Item vorhanden ist und speichert dies als Kopie in _pref: bool wäre ggf. sinnvoller um Rückmeldung zu erhalten, ob es klappt
std::string getPreferedUrl(); //Rückgabe der Url aus _pref
urlListItem getPreferedItem();
private:
urlListItem _pref; //Ablage für die Haupturl
std::list<urlListItem> _itemList; //Die Liste der structs. Da nur push_back verwendet wird, sollte die Reihenfolge nach Nutzereingabe folgen
};
|
.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101 | urlList::urlList()
{
}
void urlList::addUrl(urlListItem item) {
if( std::find( _itemList.begin(), _itemList.end(), item) != _itemList.end() ) {
_itemList.push_back(add);
}
}
void urlList::addUrl(std::string url, std::string description) {
addUrl( urlListItem(url, description) );
}
std::map<std::string, std::string> urlList::asMap() {
std::map<std::string, std::string> map;
for ( std::list<urlListItem>::iterator i = _itemList.begin(); _itemList.end(); ++i ) {
map.insert(*i->m_url; *i->m_desc;);
}
return map;
}
std::list<string> urlList::getDescriptionList() {
std::list<string> lst;
for ( std::list<urlListItem>::iterator i = _itemList.begin(); _itemList.end(); ++i ) {
lst.insert(*i->m_desc;);
}
return lst;
}
std::list<string> urlList::getUrlList() {
std::list<string> lst;
for ( std::list<urlListItem>::iterator i = _itemList.begin(); _itemList.end(); ++i ) {
lst.insert(*i->m_url;);
}
return lst;
}
std::list<urlListItem> urlList::getItemList() {
return _itemList;
}
urlListItem urlList::getPreferedItem() {
return _itemList.front();
}
std::string urlList::getPreferedUrl() {
urlListItem i = _itemList.front();
return i.m_url;
}
void urlList::removeUrl(std::string url) {
for ( _itemList::iterator i = _itemList.begin(); _itemList.end(); ++i ) {
if( *i->m_url == url) _itemList.remove(*i);
}
}
void urlList::removeUrl(urlListItem item) {
_itemList.remove(item);
}
void urlList::setPrefered(urlListItem item) {
if( std::find( _itemList.begin(), _itemList.end(), item) != _itemList.end() ) {
//item already in list:
if( _pref == item) return;
}
else addUrl(item);
_pref=item;
}
void urlList::setPrefered(std::string url) {
for ( _itemList::iterator i = _itemList.begin(); _itemList.end(); ++i ) {
if( *i->m_url == url) setPrefered(*i);
}
}
void urlList::changeDescription(std::string url, std::string desc) {
for ( _itemList::iterator i = _itemList.begin(); _itemList.end(); ++i ) {
if( *i->m_url == url) *i->m_desc = desc;
}
}
std::string getDescription(std::string url) {
for ( _itemList::iterator i = _itemList.begin(); _itemList.end(); ++i ) {
if( *i->m_url == url) return *i->m_desc;
}
return std::string("");
}
|
|