ok

img

XML

Ho realizzato una piccola libreria C++ in grado di assemblare file xml e leggerli.
La libreria si compone di un set di costruttori e di metodi essenziali con cui è possibile costruire tutta la ramificazione tipica di un documento xml.

Node(std::string tag, Node *parent, std::string attributes, std::string content);
Node(std::string tag, std::string attributes, std::string content);
Node(std::string tag);
Node();

Ciascun costruttore genera un nodo.
Il primo costruttore impone al programmatore di inserire tutte le informazioni necessarie alla costruzione del nodo (nome del tag, attributi, contenuto e genitore).
Il secondo costruttore impone al programmatore di definire solo tre paramenti (tag, attributi e contenuto).
Nel terzo è sufficiente l'inserimento del solo tag (mentre attributi e contenuto saranno considerati vuoti).
Nel quarto costruttore non vanno inseriti parametri. In tal caso tag, attributi e contenuto risulteranno vuoti e il genitore non definito.

Oltre ai metodi intuitivi di tipo get e set per operare sulle proprietà fondamentali del nodo:
std::string Node::getTag();
std::string Node::getAttributes();
std::string Node::getContent();
void Node::setTag(std::string tag);
void Node::setContent(std::string content);
void Node::setAttributes(std::string attributes);
Abbiamo dei metodi ulteriori che contribuiscono a strutturare il file xml:
int Node::getHierarchy(); // restituisce il valore della gerarchia (il nodo root è sempre 0)
Node *Node::getParent(); // restituisce il nodo genitore (se si usa in riferimento al nodo root il metodo mostra un messaggio di errore)
Node *Node::getChild(int n); // restituisce il n-esimo figlio del nodo in questione (se il figlio non esiste viene mostrato un errore)
void Node::addChild(Node *child); // aggiunge il nodo child al nodo in oggetto
static void Node::show(Node *node); // mostra tutti i nodi che discendono dal nodo parametro (se si vuole visualizzare tutto il documento basta passare il nodo root)
static void Node::save(Node *node, std::string filename); // salva il file xml
static Node *Node::load(std::string filename); // carica il file xml e restituisce il nodo root
Di seguito un piccolo esempio di utilizzo della libreria: 
//
// main.cpp
//
#include "Node.h"
#include <iostream>

int main(int argc, char **argv)
{
	Node *root = new Node("1");
	root->addChild(new Node("2"));
	root->getChild(0)->addChild(new Node("3"));
	root->getChild(0)->addChild(new Node("4"));
	root->getChild(0)->getChild(1)->addChild(new Node("5"));
	root->getChild(0)->getChild(1)->getChild(0)->addChild(new Node("6"));
	root->getChild(0)->getChild(1)->getChild(0)->addChild(new Node("7"));
	root->getChild(0)->getChild(1)->getChild(0)->getChild(1)->addChild(new Node("8"));
	root->getChild(0)->getChild(1)->getChild(0)->getChild(1)->addChild(new Node("9"));
	root->getChild(0)->getChild(1)->getChild(0)->getChild(1)->addChild(new Node("10"));
	root->getChild(0)->addChild(new Node("11"));
	root->getChild(0)->getChild(2)->addChild(new Node("12"));
	root->getChild(0)->getChild(2)->getChild(0)->addChild(new Node("13"));
    Node::save(root, "prova.xml");
}

result:
<1>
	<2>
		<3>
		</3>
		<4>
			<5>
				<6>
				</6>
				<7>
					<8>
					</8>
					<9>
					</9>
					<10>
					</10>
				</7>
			</5>
		</4>
		<11>
			<12>
				<13>
				</13>
			</12>
		</11>
	</2>
</1>

Il programma, partendo da un nodo root e utilizzando i metodi getChild e addChild, costruisce tutta la struttura xml e la salva nel file prova.xml.
//
// Node.h
//
#ifndef Node_h
#define Node_h
#include <string>
#include <vector>

class Node
{
    private:

    std::string tag;
    std::string attributes;
    std::string content;
    int hierarchy;
    Node *parent;
    std::vector <Node*> children;

    public:

    Node(std::string tag, Node *parent, std::string attributes, std::string content);
    Node(std::string tag, std::string attributes, std::string content);
    Node(std::string tag);
    Node();
    ~Node();

    void setTag(std::string tag);
    void setContent(std::string content);
    void setAttributes(std::string attributes);
    void setParent(Node *parent);
    void setHierarchy(int hierarchy);
    void addChild(Node *child);
    void removeChild(int n);
    int countChildren();
    std::string getTag();
    std::string getContent();
    std::string getAttributes();
    int getHierarchy();
    Node *getChild(int n);
    Node *getParent();
    static std::string toString(Node *node);
    static void show(Node *node);
    static void save(Node *node, std::string filename);
    static Node *load(std::string filename);
};

#endif

//
// Node.cpp
//
#include "Node.h"
#include <iostream>
#include <fstream>

Node::Node(std::string tag, Node *parent, std::string attributes, std::string content)
{
    this->setTag(tag);
    this->setParent(parent);
    this->setContent(content);
    this->setAttributes(attributes);
}

Node::Node(std::string tag, std::string attributes, std::string content)
{
    this->setTag(tag);
    this->setContent(content);
    this->setAttributes(attributes);
    this->parent = 0;
}

Node::Node(std::string tag)
{
    this->setTag(tag);
    this->setContent("");
    this->setAttributes("");
    this->parent = 0;
}

Node::Node()
{
    this->setTag("");
    this->parent = 0;
    this->hierarchy = 0;
    this->setContent("");
    this->setAttributes("");
}

Node::~Node()
{
    for(int i = 0; i < this->children.size(); i++)
    {
        delete this->children[i];
    }
    this->children.clear();
}

void Node::setTag(std::string tag)
{
    this->tag = tag;
}

void Node::setContent(std::string content)
{
    this->content = content;
}

void Node::setAttributes(std::string attributes)
{
    this->attributes = attributes;
}

void Node::setParent(Node *parent)
{
    parent->addChild(this);
    this->parent = parent;
}

void Node::setHierarchy(int hierarchy)
{
    this->hierarchy = hierarchy;
}

std::string Node::getTag()
{
    return this->tag;
}

std::string Node::getContent()
{
    return this->content;
}

std::string Node::getAttributes()
{
    return this->attributes;
}

Node *Node::getParent()
{
    if(this->hierarchy > 0)
    {
        return this->parent;
    }
    else
    {
        std::cout << "ERROR: root doesn't have a parent.\n";
        return 0;
    }
}

int Node::getHierarchy()
{
    return this->hierarchy;
}

void Node::addChild(Node *child)
{
    this->children.push_back(child);
    child->setHierarchy(this->hierarchy + 1);
}

void Node::removeChild(int n)
{
    if(n < this->children.size())
    {
        delete this->children[n];
        this->children.erase(this->children.begin() + n);
    }
    else
    {
        std::cout << "ERROR: child not exists.\n";
    }
}

Node *Node::getChild(int n)
{
    if(n < this->children.size())
    {
        return this->children[n];
    }
    else
    {
        std::cout << "ERROR: child not exists.\n";
        return 0;
    }
}

int Node::countChildren()
{
    return this->children.size();
}

std::string Node::toString(Node *node)
{
    std::string str = "";
    for(int i = 0; i < node->getHierarchy(); i++)
	{
		str += "\t";
	}
	str += "<" + node->getTag();
    if(node->getAttributes() != "")
    {
        str += " " + node->getAttributes();
    }
    str += ">\n";
	if(node->countChildren())
	{
		for(int i = 0; i < node->countChildren(); i++)
		{
			str += Node::toString(node->getChild(i));
		}
	}
	for(int i = 0; i < node->getHierarchy(); i++)
	{
		str += "\t";
	}
	str += "</" + node->getTag() + ">\n";
    return str;
}

void Node::show(Node *node)
{
    std::cout << Node::toString(node);
}

void Node::save(Node *node, std::string filename)
{
    std::ofstream myfile(filename);
    if(myfile.is_open())
    {
        std::string str = Node::toString(node);
        myfile << str;
        myfile.close();
    }
}

Node *Node::load(std::string filename)
{
    Node *root;
    std::ifstream file;
	file.open(filename.c_str(), std::ios::in);
	std::string str;
	if(file.is_open())
	{
		while(!file.eof())
		{
			std::string s;
			getline(file, s);
			str += s + "\n";
		}
		file.close();
	}
    std::vector <Node*> vec;
	unsigned int hierarchy = 0;
	bool h = true;
	while(h)
	{
		int j = str.find("<");
		if(j == -1){h = false;}
		else
		{
			int k = str.find(">");
			std::string tag;
			std::string attributes;
			std::string t = str.substr(j + 1, k - j - 1);
			std::string c = str.substr(0, j);
			int l = t.find(" ");
			if(l != -1)
			{
				tag = t.substr(0, l);
				attributes = t.substr(l + 1);
			}
			else
			{
				tag = t;
				attributes = "";
			}
			if(tag[0] == 47)
			{
				hierarchy--;
                vec.pop_back();
			}
			else if(t.substr(0, 3) == "!--" && t.substr(t.length() - 2) == "--")
			{
				// comment
			}
			else
			{
                Node *node = new Node();
				node->setHierarchy(hierarchy);
				node->setTag(tag);
				node->setAttributes(attributes);
                if(vec.size() == 0)
                {
                    root = node;
                }
                else
                {
                    node->setParent(vec.back());
                }
                vec.push_back(node);
                hierarchy++;
            }
            str = str.substr(k + 1);
        }
    }
    return root;
}
C++ xml

Biografia

Mi chiamo Cosimo Saccone e sono un programmatore napoletano di 44 anni con oltre 35 anni di esperienza nella programmazione (BASIC, Assembly). Realizzo progetti e programmi utilizzando i principali e più diffusi linguaggi (C, C++, PHP, Javascript, HTML) e software per la grafica (Photoshop, Illustrator, 3dsMax). Anche se la grafica rappresenta il mio principale settore di interesse, non disdegno il lavoro di back-end e di organizzazione dati e sono attento agli aspetti di efficienza e di risparmio delle risorse tipica della programmazione di basso livello (specie nel settore della grafica 3d). Realizzo siti internet, applicativi desktop e servizi di vario tipo. Ho una buona conoscenza della libreria OpenGL per lo sviluppo di applicazioni 3d interattive in C/C++. Cerco di adottare uno stile di programmazione fortemente ordinato e modulare. Possiedo, inoltre, una buona capacità di elaborazione della documentazione. Ho vari hobbies tra cui la pittura, la ginnastica e le lunghe passeggiate in solitudine.

facebook instagram youtube
xml social login
HTML5 Template create by Cosimo Saccone 2022
html5 validator css3 validator
CosimoSacconeNapoliCampaniaItaliainformaticaprogrammazionepccomputerc++cjavascriptphphtml

Al fine di migliorare l’esperienza di navigazione sul nostro sito noi di cosimosaccone.com e i nostri partner selezionati elaboriamo i dati personali, compreso l’indirizzo IP e le pagine visitate, in relazione alla tua navigazione nei contenuti del sito, per i seguenti scopi:

Accesso alle informazioni
Dati precisi di geolocalizzazione
Misurazione del pubblico
Pubblicità e contenuti personalizzati
Ti ricordiamo che il termine cookie si riferisce a una porzione di dati inviati al tuo browser da un web server. Il cookie viene memorizzato sul tuo dispositivo e riconosciuto dal sito web che lo ha inviato in ogni navigazione successiva. Se vuoi saperne di più e compiere una scelta diversa, come il rifiuto del trattamento dei tuoi dati personali, clicca qui sulla nostra privacy policy. Potrai sempre modificare le tue scelte e impostare i singolo cookies selezionando il bottone qui sotto.
OK