contact.cpp

// -*- C++ -*-
/*
    $Id: contact_8cpp-source.html,v 1.1 2004/10/05 21:12:01 mentat Exp $

    GNU Messenger - The secure instant messenger
    Copyright (C) 1999-2002  Henrik Abelsson <henrik@abelsson.com>
    parts Copyright (C) 2002-2004 Jesse Lovelace <jesse at aslogicsys dot com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <string>
#include <list>

#include "gm/debug.h"
#include "gm/xmlnode.h"
#include "gm/contact.h"

namespace GNUMessenger {

using namespace std;

Contact::Contact(const Contact& other):
    XMLNode(other)
{
    m_session = other.m_session;
}

Contact::Contact()
{
    XMLNode::setName("contact");
}


Contact::Contact(const XMLNode &config):
       XMLNode(config)
{
    
}

string Contact::getServerId( const string& proto ) const
{
    
    try {
        if (child("protocols").hasChild(proto))
            return child("protocols").child(proto).property("login");
    } catch (XMLNode::InvalidChild &e) { 
        LOG_DEBUG("No protocols group");
    }
      
    return "";
}

void Contact::setStatus(const string& proto, Status state)
{
    if (child("protocols").hasChild(proto)) {
        child("protocols").child(proto).setProperty("status",state);
    } else {
        LOG_THROW("Contact::setStatus: invalid protocol", XMLNode::InvalidChild);
    }

}

Contact::Status Contact::getStatus(const string& proto) const
{
    if (child("protocols").hasChild(proto)) {
        int status = child("protocols").child(proto).intProperty("status");
        return Status(status);
    } else {
        LOG_THROW("Contact::getStatus: invalid protocol", XMLNode::InvalidChild);
    }

    return Error;
}

Contact::Status Contact::getOverallStatus() const
{
    if (!hasChild("protocols"))
        return Error;
    
    Status bestSoFar = Offline;
    
    vector<XMLNode> xml = child("protocols").const_children();
    for (unsigned int i = 0; i < xml.size(); i++) {
        Status temp = (Status)xml[i].intProperty("status");
        
        if (temp == Online)
            return Online;
        else 
            if (temp > bestSoFar)
                return temp;
    }
    
    return Error;
}


void Contact::setServerId(const string& proto, const string& id)
{
    if (proto.length() == 0){
        LOG_ERROR("PROTO LENGTH ZERO!");
        return;
    }
    
    LOG_DEBUG("Contact::setServerId: " << proto << " " << id);
    // set the server Id for a specified protocol
    if (!child("protocols").hasChild(proto))
        child("protocols").addChild(proto);

    child("protocols").child(proto).setProperty("login", id);
}


#if 0
bool Contact::activateProtocol() // approx worse case, this function only, 2*O(N)
{
    vector<XMLNode> nets = m_session.children();    
    string current; // best protocol found to date
    string alreadyActive; // the currently active protocol, if one exists
    unsigned int index; // the index of the 'good' protocol
    unsigned int i; // loop variable
    
    // first we want to find the active protocol if one exists,
    // and set it to not active
    for (i = 0; i < nets.size(); i++)
        if (nets[i].property("active") == "true")
        {
            alreadyActive = nets[i].name();
            nets[i].setProperty("active", "false");
        }

    // now search for another active network
    for (i = 0; i < nets.size(); i++)
        if ((nets[i].intProperty("status") == Online) && (nets[i].name() != alreadyActive))
        {   // if we find a protocol online that is not the already active one, go with it
            current = nets[i].name();
            index = i; // keep record of index so we dont have to search again
            break; // hmm, i know people dont like breaks, but this clearly
                   // exits the loop when a 'good' contact is found
        }
        else
            if ((nets[i].intProperty("status") != Offline) &&
                (current == "")) // otherwise, assign one that isn't offline and loop
            {
                current = nets[i].name();
                index = i;
            }
#if 0 // on second thought, lets not add another O(N) function  
    // now lets set all the other nets to not active
    // so as to not confuse the program
    for (i = 0; i < nets.size(); i++)
    {
        nets[i].setProperty("active", "false");
    }
#endif  
    if (current == "") // if no protocol is found, return false
    {
        debug() << "No suitable protocol found in activateProtocol()\n";
        return false;
    }
    else
    {
        debug() << "Protocol activated: " << nets[i].name() << endl;
        nets[index].setProperty("active", "true");
        return true;
    }
}
#endif

void Contact::addProtocol(const string& proto)
{
    if (child("protocols").hasChild(proto))
        return;

    child("protocols").addChild(proto);
}

bool Contact::isOK() const {
    if (property("destroyed") == "true")
        return false;
    return true;
}
        
void Contact::Destroy() {
    setProperty("destroyed", "true");
}

bool Contact::hasProtocol(const string& str) const
{
    if (!hasChild("protocols"))
        return false;
    
    if (child("protocols").hasChild(str))
        return true;
    
    return false;
}

string Contact::getProtocol() const
{
    if (!hasChild("protocols"))
        return "";
    
    vector<XMLNode> xml = child("protocols").const_children();
    
    // try first searching for online protocol
    for (unsigned int i = 0; i < xml.size(); i++) {
        if (xml[i].intProperty("status") == Online)
            return xml[i].name();
    }

    // then search for any non-offline protocol
    for (unsigned int i = 0; i < xml.size(); i++) {
        if (xml[i].intProperty("status") != Offline)
            return xml[i].name();
    }

    return "";
    
}

Contact& Contact::operator=(const Contact &other)
{
    other.m_xmlData->ref();

    if (m_xmlData && m_xmlData->deref()) {
        delete m_xmlData;
        m_xmlData=0;
    }

    m_xmlData=other.m_xmlData;

    m_session = other.m_session;

    return *this;
}

bool operator < (const Contact& lhs, const Contact& rhs)
{
    return (lhs.name() < rhs.name());
    //return (c1.getName() < c2.getName());
}

bool operator==(const Contact& lhs, const Contact& rhs)
{
    return (lhs.m_xmlData == rhs.m_xmlData);
}

bool operator!=(const Contact& lhs, const Contact& rhs)
{
    return !(lhs==rhs);
}

} 

---