Protocol.h

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

/*
 * Protocol.h
 *
 *  Created on: 09.04.2011
 *      Author: nick
 */

#ifndef PROTOCOL_H_
#define PROTOCOL_H_

#include "Node.h"
#include <string>
#include <map>
#include "TagHandler.h"
#include "TagIQ.h"
#include <expat.h>
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <string.h>
#include "../options.h"
#define BUFFSIZE        8192
using namespace std;
#define debug_out
//template <class Listener_T>
//template <class Listener_T> class Protocol;
//typedef void (Protocol<Listener_T>::*packetRecerver)(Node*);

/*template  <class Listener_T>*/
typedef multimap<pair<string,string>, TagHandler<Node>::PTagHandler> TagHandelrsMapT;
//                                              //subtag //sub-xmlns
//typedef multimap<pair<string,string>, TagHandler<TagIQ>::PTagHandler> IQHandelrsMapT;
struct IQHandleD{
        string xmlns;
        string subtagName;
        TagHandler<TagIQ>::PTagHandler handler;
};

typedef list<IQHandleD> IQHandelrsMapT;
/*struct IQRespDKey{
        string xmlns;
        string subtagName;
        string id;
        bool operator<(const IQRespDKey &obj2) const;*/
        /*bool operator==(const IQRespDKey &obj2) const;
        bool operator!=(const IQRespDKey &obj2) const;*/
        //friend bool operator<(const IQRespDKey &obj1,const IQRespDKey &obj2);
//};

/*      bool operator<(const IQRespDKey &obj){
                return (this->id<obj.id) && (this->subtagName<obj.subtagName) &&
                                (this->xmlns<obj.xmlns);
        }*/
/*      bool operator==(const IQRespDKey& obj){
                return (this->id==obj.id) && (this->subtagName==obj.subtagName) &&
                                (this->xmlns==obj.xmlns);
        }

        bool operator>(const IQRespDKey& obj){
                return (this->id>obj.id) && (this->subtagName>obj.subtagName) &&
                                (this->xmlns>obj.xmlns);
        }

        bool operator<=(const IQRespDKey& obj){
                return !(*this>obj);
        }

        bool operator!=(const IQRespDKey& obj){
                return !(*this==obj);
        }

        bool operator<(const IQRespDKey& obj){
                return (!(*this>obj))&&(!(*this==obj));
        }

        bool operator>=(const IQRespDKey& obj){
                return (*this>obj)||(*this==obj);
        }*/
//};
//static pthread_mutex_t cs_mutex = PTHREAD_MUTEX_INITIALIZER;
//static pthread_mutex_t cs_mutex1 = PTHREAD_MUTEX_INITIALIZER;

//static pthread_mutex_t cs_mutexDEL = PTHREAD_MUTEX_INITIALIZER;
//static pthread_mutex_t cs_mutexUNIC = PTHREAD_MUTEX_INITIALIZER;
//static pthread_mutex_t cs_mutexNewNode = PTHREAD_MUTEX_INITIALIZER;
//static TagHandler<TagIQ>::PTagHandler valPredIQDEL;
//bool delIQPredicate(IQHandleD hd);

//static pthread_mutex_t cs_mutex2 = PTHREAD_MUTEX_INITIALIZER;

struct IQRespD{
        TagIQ result;
        string xmlns;
        string subtagName;
        int semID;
        ~IQRespD();
};

class Protocol/*:public TagHandler<Node>*/ {
public:
        //typedef void (Listener_T::*packetRecerver)(Node*);
        //typedef void (Protocol <Listener_T>::*packetRecerver)(Node*);
        //typedef void (*packetRecerver)(Node*);                
        pthread_mutex_t cs_mutex;
        pthread_mutex_t cs_mutex1;
        pthread_mutex_t cs_mutexNewNode;
        pthread_mutex_t cs_mutexDEL;
        //
        pthread_mutex_t mutDelEndNodRu;
        unsigned int num_run_threads;
        pthread_cond_t cond_del_element;
protected:
        pthread_attr_t attr;
        //Ответы на запросы, при запросе с ответом
        multimap</*IQRespDKey*/string,IQRespD> req_id;

        char read_Buffer[BUFFSIZE];
        int skt_id;
        XML_Parser xml_parser;
        int curDeph;
        Node* topNode;
        Node* curNode;
        Node* curNodeSend;
        void handlerNode(Node* curNodeL);
        void handlNodes(Node* curNodeL,TagHandelrsMapT::iterator begin,TagHandelrsMapT::iterator end);
        //void handlIQs(IQHandelrsMapT::iterator begin,IQHandelrsMapT::iterator end, TagIQ &iq);
        void handlerIQ(Node* curNodeL);
        void sendNodeStart(Node &stanza);
        void sendNodeEnd(Node &stanza);
        //Обработка стандартного содержимого  протокола, например iq тега
        //multimap<string,packetRecerver> listeners;
        //list <packetRecerver> listeners;
        TagHandelrsMapT tagHandlers;
        IQHandelrsMapT  iqHandlers;
        pthread_t nodeThread;
public:
        Protocol();
        ~Protocol();
        //packetRecerver func;
        void parserCreate(int sktID);
        Node* getCurNodeSend(){return curNodeSend;}
        void sendNode(Node &stanza);
        //void addNodeListener(/*packetRecerver func*/);
        void addTagHandler(TagHandler<Node>::PTagHandler handler, string name="", string xmlns="");
        void addIQHandler(TagHandler<TagIQ>::PTagHandler handler, string xmlns="", string name=QUERY_TAG);
        void removeIQHandler(TagHandler<TagIQ>::PTagHandler handler);
        void startParsing(/*int sktID*/);
        virtual void startXMLTagNodeHandler(Node *node);
        virtual void endXMLTagNodeHandler(Node *node);
        //Отправка в сокет не XML содержимого
        void sendString(string data);
        void manadgeIQResp(TagIQ& st);
        //TagIQ sendIQResp(TagIQ& st);
        TagIQ sendIQResp(TagIQ& st, string resultXMLNS, string resultSubTagName);
        //void recevedStanza(Node* stanza){};
        friend void startTag(void *userData,const XML_Char *name, const XML_Char **atts);
        friend void endTag(void *userData,const XML_Char *name);
        friend void characterData (void *userData,const XML_Char *s,int len);
        friend void* node_threadFunc(void* clnt);
        //virtual void handleTag(Node &tag);
};

#endif /* PROTOCOL_H_ */