Node.cpp

См. документацию.

/*
 * Node.cpp
 *
 *  Created on: 08.04.2011
 *      Author: nick
 */

#include "Node.h"
#include <iostream>
//Маразматическая замена подстроки в строке, блин...
void replace(std::string& text, std::string s, std::string d){
  for (int index=text.find(s, 0); index!=-1; index=text.find(s, index) ) {
    text.replace(index, s.length(), d);
    index+=d.length();
  }
}

string XMLescape(string txt){
        replace(txt,"&","&amp;");
        replace(txt,">", "&gt;");
        replace(txt,"\"", "&quot;");
        replace(txt,"\x0C", "");
        replace(txt,"\x1B", "");
        return txt;
}

Node::Node(string name,  Node* parent,string xmlns) {
        pthread_mutex_init(&add_remove_mutex,NULL);
        //isDuplicate=false;
        this->name=name;
        this->parent=parent;
        if(xmlns!=""){
                //attrs["xmlns"]=xmlns;
                setAttribute("xmlns",xmlns);
        }
        if (parent){
                parent->addChild(this);
        }
}

Node::Node(string name, map <string, string> /*&*/attrs,  Node* parent=NULL) {
        pthread_mutex_init(&add_remove_mutex,NULL);
        // TODO Auto-generated constructor stub
        //isDuplicate=false;
        this->name=name;
        this->parent=parent;
        this->attrs=attrs;
        if (parent){
                parent->addChild(this);
        }
}

void Node::deleteByXMLNS(string xmlns){
        Node* n=this->getKind(xmlns);
        if (n!=NULL){
                cout<<"DELETE NOT UNIQUE NAMESPACE!!!!:"<<xmlns<<endl;
                delete n;
        }
}

void Node::addChild(Node* child){
        map <string, string>::iterator ii=child->attrs.find("xmlns");
        if (ii!=child->attrs.end()){
                deleteByXMLNS(ii->second);
        }
        child->parent=this;
       pthread_mutex_lock(&add_remove_mutex);
        kinds.push_back(child);
       pthread_mutex_unlock(&add_remove_mutex);
}

void Node::setNamespace(string xmlns){
        setAttribute("xmlns",xmlns);
        //attrs["xmlns"]=xmlns;
}

string Node::toXMLStringStart(){
        string res="";
        res+="<"+XMLescape(name);
        map <string, string> ::iterator it=attrs.begin();
        while (it!=attrs.end()){
                res+=" "+XMLescape((*it).first)+"=\""+XMLescape((*it).second)+"\"";
                it++;
        }
        res+=">\n";
        return res;
}

string Node::toXMLStringEnd(){
        return "</"+name+">\n";
}

string Node::toXMLString(){
        string res="";
        #ifdef debug_output
        cout<<"-1-"<<endl;
        #endif
        res+="<"+XMLescape(name);
        #ifdef debug_output
        cout<<"-2-"<<endl;
        #endif
        map <string, string> ::iterator it=attrs.begin();
        #ifdef debug_output
        cout<<"-3-"<<endl;
        #endif
        while (it!=attrs.end()){
            #ifdef debug_output
                cout<<"-4-"<<endl;
            #endif
                res+=" "+XMLescape((*it).first)+"=\""+XMLescape((*it).second)+"\"";
                it++;
        }
        #ifdef debug_output
        cout<<"-5-"<<endl;
        #endif
        pthread_mutex_lock(&add_remove_mutex);
        if ((kinds.begin()==kinds.end())&&(xmlBody.length()==0)){
                res+="/>\n";
        }else{
                res+=">";
                if (kinds.begin()==kinds.end()){
                        res+=XMLescape(xmlBody);
                }else{
                        res+="\n";
                        list<Node*>::iterator p=kinds.begin();
                        while (p!=kinds.end()){
                                res+=(*p)->toXMLString();
                                p++;
                        }
                }
                res+="</"+name+">\n";
        }
        pthread_mutex_unlock(&add_remove_mutex);
        #ifdef debug_output
        cout<<"-6OK-"<<endl;
        #endif
        return res;
}


void Node::copyKinds(const Node &basedNode){
        #ifdef debug_output
        cout<<"copy KINDS NODE!"<<endl;
        cout<<"============= copy: ============= :"<<basedNode.name<<endl;
        #endif
        //isDuplicate=true;
        this->name=basedNode.name;      
        //this->kinds=basedNode->kinds;//
        //Первая нода должна ссылаться на тот парент от которого была создана дублируемая
        this->parent=basedNode.parent;
        this->attrs=basedNode.attrs;
        this->xmlBody=basedNode.xmlBody;
        pthread_mutex_lock(&add_remove_mutex);
        list<Node*>::const_iterator it=basedNode.kinds.begin();
        while (it!=basedNode.kinds.end()){
                Node* n=new Node(*(*it));
                //А ноды дети должны ссылаться на себя, и здесь мы ссылку перепишим
                n->parent=this;
                #ifdef debug_output
                cout<<"============= addKinds: ============= :"<<n->name<<endl;
                #endif
                this->kinds.push_back(n);
                #ifdef debug_output
                cout<<"ka "<<n->name<<endl;
                #endif
                ++it;
        }
        pthread_mutex_unlock(&add_remove_mutex);
        #ifdef debug_output
        cout<<"============= copyed: ============= :"<<basedNode.name<<endl;
        #endif
}
//Мда, но в киндсах останется тот класс который и был, раньше, а не станза, в нод...
Node::Node(const Node &basedNode){
        pthread_mutex_init(&add_remove_mutex,NULL);
        copyKinds(basedNode);
}

Node* Node::getKind(string xmlns){
        Node* res=NULL;
        pthread_mutex_lock(&add_remove_mutex);
        list<Node*>::iterator it=kinds.begin();
        while (it!=kinds.end()){
                if ((*it)->getNamesapace()==xmlns){
                        res= *it;
                }
                ++it;
        }
        pthread_mutex_unlock(&add_remove_mutex);
        return res;
}

_Kinds_iterator Node::kindsNameBegin(string name){
        _Kinds_iterator ki;
        ki.beginitem=kinds.begin();
        ki.enditem=kinds.end();
        ki.curitem=kinds.begin();
        ki.name=name;
        if ((*ki.curitem)->name!=name){
                ++ki;
        }
        return ki;
}

_Kinds_iterator Node::kindsNameEnd(string name){
        _Kinds_iterator ki;
        ki.beginitem=kinds.begin();
        ki.enditem=kinds.end();
        ki.curitem=kinds.end();
        ki.name=name;
        return ki;
}

void Node::destroyKinds(){
        // TODO Auto-generated destructor stub
        //list<Node*>::iterator p=kinds.begin();
        /*while ((p!=kinds.end())&&(!isDuplicate)){
                delete (*p);
                p++;
        }*/
        #ifdef debug_output
        cout<<"-Node1-"<<endl;
        //cout<<"XML "<<this->toXMLString();
        cout<<name<<endl;        
        cout<<"-Node2-"<<endl;
        #endif
        while /*(*/(kinds.begin()!=kinds.end())/*&&(!isDuplicate))*/{
                delete (*kinds.begin());
                //Node* nd=kinds.pop_back();
                //delete nd;
                        //p++;
        }
        #ifdef debug_output
        cout<<"-Node3-"<<endl;
        #endif
        if(parent!=NULL){
            #ifdef debug_output
                cout<<"pre remove kind"<<endl;
            #endif
                this->parent->removeKind(this);
            #ifdef debug_output
                cout<<"post remove kind"<<endl;
            #endif
        }
        #ifdef debug_output
        cout<<"=============destroyed ===========: "<<name<<endl;
        #endif
/*      if((!isDuplicate)&&(parent!=NULL)){
                cout<<"delete parent:"<<parent->name<<" "<<this->name<<endl;
                this->parent->removeKind(this);
        }*/
        //kinds.clear();
}

Node &Node::operator=(Node &obj){
    #ifdef debug_output
        cout<<"operator = Node"<<endl;
    #endif
        destroyKinds();
        copyKinds(obj);
        return *this;
}

void Node::setXMLBody(long body){
        stringstream res;
        res<<body;
        xmlBody=res.str();
}

long Node::getXMLBodyInt(){
        istringstream res(xmlBody);
        long r=0;
        res>>r;
        return r;
}

long Node::getAttributeInt(string name){
        istringstream res(attrs[name]);
        long r=0;
        res>>r;
        return r;
}

bool Node::parentContainSelf(){
        pthread_mutex_lock(&(this->parent->add_remove_mutex));
        bool b=(this->parent!=NULL)&&(find(this->parent->kinds.begin(),
                this->parent->kinds.end(),this)!=this->parent->kinds.end());
        pthread_mutex_unlock(&(this->parent->add_remove_mutex));
        return b;
}

void Node::setAttribute(string name, string value){
        if (name=="xmlns"){
                //Бывает ситуация когда родитель не сорежит потомка в своих детях,
                //когда это копия, от потомка верхнего уровня, тогда смысла заменять себя
                //в нем нету
                if(parentContainSelf()){
                        this->parent->deleteByXMLNS(value);
                }
        }
        attrs[name]=value;
}

void Node::setAttribute(string name, long value){
        stringstream res;
        res<<value;
        setAttribute(name,res.str());
}

Node::~Node() {
        destroyKinds();
        pthread_mutex_destroy(&add_remove_mutex);
}
void Node::removeKind(Node* node){
    pthread_mutex_lock(&add_remove_mutex);
    kinds.remove(node); /*delete node;*/
    pthread_mutex_unlock(&add_remove_mutex);
}