---

Connector.C

Go to the documentation of this file.

#include "Connector.h"
#define DEFAULT_PORT 6780

Connector::Connector() {
        init(DEFAULT_PORT,DEFAULT_PORT+1,DEFAULT_PORT+2,DEFAULT_PORT+3);
}
Connector::~Connector() {
        list<ConnectionWrap *>::iterator iter;
        for (iter = allConnections->begin(); iter != allConnections->end(); iter++) {
                (*iter)->disconnect();
                delete *iter;
        }
        allConnections->clear();
        
        list<ConfigConnection *>::iterator citer;
        for (citer = configConnections->begin(); citer != configConnections->end(); citer++) {
                (*citer)->disconnect();
                delete *citer;
        }
        configConnections->clear();
        currentConfig = NULL;
        {
                list<ConnectionWrap *>::iterator iter;
                for (iter = allConnections->begin(); iter != allConnections->end(); iter++) {
                        allConnections->erase(iter);
                        delete (*iter);
                }
        }
        {
                list<ConfigConnection *>::iterator iter;
                for (iter = configConnections->begin(); iter != configConnections->end(); iter++) {
                        configConnections->erase(iter);
                        delete (*iter);
                }
        }
        delete allConnections;
        delete configConnections;
        delete (MessageExecutor*)messageExecutor;
        delete connectionFactory;
        delete bf;
}
Connector::Connector(int start) {
        init(start,start+1,start+2,start+3);
}
Connector::Connector(int inputport,int outputport,int filterport, int configport) {
        init(inputport,outputport,filterport,configport);
}
void Connector::init(int inputport,int outputport,int filterport, int configport) {
        bf = new BufferedFileFactory();
        connectionFactory = new ConnectionFactory(bf,inputport,outputport,filterport,configport);
        updated();
        allConnections = new list<ConnectionWrap *>();
        messageExecutor = new MessageExecutor();
        configConnections = new list<ConfigConnection *>();
        ConnectorSingleton().setConnector(this);
        quit = false;
        processUpdate = lastUpdated;
}
int Connector::lastUpdate() {
        return lastUpdated;
}
void Connector::lastChange() {
        char number[12];
        snprintf(number,12,"%d",lastUpdate());
        string final = "<lastChange>";
        final += "<time>";
        final += string(number);
        final += "</time></lastChange>";
        currentConfig->write(final.c_str(),final.size());
}
void Connector::updated() {
        lastUpdated = time(NULL);
}
list<ConnectionWrap *> * Connector::getConnectionList() {
        return allConnections;
}
void Connector::disconnect(int fd) {
        list<ConnectionWrap *>::iterator eter;
        list<ConnectionWrap *>::iterator iter;
        ConnectionWrap * it = NULL;
        int fh;
        for (eter = allConnections->begin(); eter != allConnections->end(); eter++) {
                
                fh = (*eter)->getFileHandle();
                if (fd == fh) {
                        it = *eter;
                        break;
                }
        }
        if (it!=NULL) {
                allConnections->remove(it);
                for (iter = allConnections->begin(); iter != allConnections->end(); iter++) {
                        (*iter)->disconnectFrom(it);
                }
                it->disconnect();
                updated();
                delete it;
                return;
        }
        //ERROR
        throw new string("No connection found. Could not disconnect connection");
}
void Connector::unPatch(int from, int to) {
        cout << "UNPATCH " << from << " TO " << to << "\n";
        list<ConnectionWrap *>::iterator iter;
        ConnectionWrap * fromConn = NULL;
        ConnectionWrap * toConn = NULL;
        for (iter = allConnections->begin(); iter != allConnections->end(); iter++) {
                int fd = (*iter)->getFileHandle();
                if (fd == from) {
                        fromConn = (*iter);
                } else if (fd == to) {
                        toConn = (*iter);
                }
        }
        if (fromConn == NULL || toConn == NULL) {
                throw new string("There is no patch between these connections!");
        }
        toConn->disconnectFrom(fromConn);
        updated();
}
void Connector::patch(int from, int to) {
        list<ConnectionWrap *>::iterator iter;
        ConnectionWrap * fromConn = NULL;
        ConnectionWrap * toConn = NULL;
        for (iter = allConnections->begin(); iter != allConnections->end(); iter++) {
                int fd = (*iter)->getFileHandle();
                if (fd == from) {
                        fromConn = (*iter);
                        if (toConn!=NULL) { break;}

                } else if (fd == to) {
                        toConn = (*iter);
                        if (fromConn!=NULL) { break;}
                } 
        }
        if (fromConn == NULL || toConn == NULL) {
                throw new string("There is no patch between these connections!");
        }
        if (!fromConn->readable()) {
                throw new string("This is not a valid patch!");
        }
        toConn->connectFrom(fromConn);
        updated();
}
void Connector::sendUpdate() {
        char number[12];
        if (currentConfig==NULL) {
                list<ConfigConnection *>::iterator iter;
                for (iter = configConnections->begin(); iter != configConnections->end(); iter++) {
                        currentConfig = (*iter);
                        break;
                }
                if (currentConfig==NULL) {
                        return; //No ConfigConnections
                }
        }
        string final = "<update>";
        list<ConnectionWrap *>::iterator iter;
        for (iter = allConnections->begin(); iter != allConnections->end(); iter++) {
                string * str = (*iter)->getXML();
                if (str!=NULL) {
                        final += *str;
                        delete str;
                }
        }
        snprintf(number,12,"%d",lastUpdate());
        final += "<time>";
        final += string(number);
        final += "</time></update>";
        currentConfig->write(final.c_str(),final.size());
}

void Connector::process() {
        //Call process on data connections
        //Check config connections
        //Check for new connections
        int rw = bf->process(100);
        Clock::clock++;
        if (rw) {
                list<ConnectionWrap *>::iterator iter;
                for (iter = allConnections->begin(); iter != allConnections->end(); iter++) {
                        (*iter)->process();
                }
                list<ConfigConnection *>::iterator citer;
                if (processUpdate!=lastUpdated) {
                        ConfigConnection * tmp = currentConfig;
                        for (citer = configConnections->begin(); citer != configConnections->end(); citer++) {
                                currentConfig = *citer;
                                try {
                                        sendUpdate();
                                } catch (string * err) {
                                        cout << "Disconnecting a ConfigConnection\n";
                                        configConnections->remove(currentConfig);
                                        //delete *citer;
                                        delete  currentConfig;
                                        currentConfig = NULL;
                                        delete err;
                                }
                        }
                        processUpdate = lastUpdated;
                        currentConfig = tmp;
                }
                for (citer = configConnections->begin(); citer != configConnections->end(); citer++) {
                        try {
                                if ((*citer)->isMessage()) {
                                        currentConfig = (*citer);
                                        Message *m = (*citer)->getMessage();
                                        string * mstr = m->getXML();
                                        cout << "THERE IS A MESSAGE "<< *mstr << "\n" ;
                                        try {
                                                ((MessageExecutor*)messageExecutor)->executeMessage(m);
                                        } catch (string * err) {
                                                string error = "<error>";
                                                error += *err;
                                                error += "</error>";
                                                currentConfig->write(error.c_str(),error.size());
                                        }
                                        delete m;
                                } 
                                if (processUpdate!=lastUpdated) {
                                        
                                }
                        } catch (string * err) {
                                cout << "Disconnecting a ConfigConnection\n";
                                configConnections->remove(currentConfig);
                                //delete *citer;
                                delete  currentConfig;
                                currentConfig = NULL;
                                delete err;
                                break;
                        }               
                }        
        }
        if (connectionFactory->isThereANewConnection()) {
                cout << "There is a connection!\n";
        
                ConnectionWrap * wrap = connectionFactory->processConnection();
                if (wrap!=NULL) {
                        cout << (int)(wrap->conn.floatConn->getFileHandle()) << "\n";
                        assert(wrap->conn.floatConn!=0);
                        if (wrap->type == CONFIGCONN) {
                                cout << "It's a config connection!\n";
                                configConnections->push_back(wrap->conn.configConn);
                                wrap->conn.configConn = NULL;
                                delete wrap;
                        } else if (wrap == NULL) {
                                cout << "NULL Wrapper Returned?\n";
                        } else {
                                cout << "It's not config connection!\n";
                                allConnections->push_back(wrap);
                        } 
                        updated();
                } else {
                        cout << "Connection Failed!\n";
                }
        }
}
void Connector::shutDown() {
        quit = true;

}
bool Connector::done() { 
        return quit;
}

---