triplet.h

/***************************************************************************
 *   Copyright (C) 2004 by Michael Moritz                                  *
 *   mimo@restoel.net                                                      *
 *                                                                         *
 *   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.             *
 ***************************************************************************/

#ifndef __TRIPLET_H
#define __TRIPLET_H

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <iostream>
#include <string>
// #include <sstream>
#include <stdexcept>
// #include <netdb.h>
#include "read.h"
#include "defs.h"

#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif

//sql_create_basic_3(Triplet,0,0,std::string,client_address,std::string,sender,std::string,recipient)

class Triplet
{
public:
        typedef enum {
                TM_sender,
                TM_recipient,
                TM_client,
                TM_resolved,
                TM_quotedweakclient
        }TripletMember;
        Triplet(const Reader& reader);
        Triplet(const std::string& client,const std::string& sender,const std::string& recipient,
                const std::string& client_numeric="");
        const std::string& getClientAddress() const { return _client_address; }
        const std::string& getClientAddressNumeric() const { return _client_address_numeric; }
/*
                if(_client_address_numeric.size())
                        return _client_address_numeric;
                else {
                        if( !_client_address.size() )
                                return _client_address_numeric;
                        const std::string& tStr = _client_address;
//                      std::cout << "tStr" << tStr << std::endl;
                        std::string::size_type i = tStr.find('.');
                        std::string::size_type j = 1; //skip '
                        if(tStr[0] != '\'') //unquoted
                                j = 0;
                        if(i != std::string::npos) {
                                do {
                                        //std::cout << "substr " << tStr.substr(j,i-j) << std::endl;
                                        _client_address_numeric += atoi((tStr.substr(j,i-j)).c_str());
                                        j = i+1;
                                        i = tStr.find('.',j);
                                        if(i == std::string::npos) {
                                                i = tStr.find('\'',j);
                                                if((i == std::string::npos) && (tStr[0] != '\'')) { //unquoted
                                                        //std::cout << "substr " << tStr.substr(j,i) << std::endl;
                                                        _client_address_numeric += atoi((tStr.substr(j,i)).c_str());
                                                        break;
                                                }
                                        }
                                }while( i != std::string::npos);
                        }
                        return _client_address_numeric;
                }
        };*/
        const std::string getClientAddressNumericStr(const char sep='.',unsigned size=0) const;

        const std::string getClientAddressNumericStrSQL(const std::string& sep,const std::string& base,
                unsigned start,const std::string& afterstart,unsigned mult,unsigned size) const;
        
        const std::string getResolved() const { return _resolved; }

        const std::string& getResolveError() const { return _not_resolved; }
        const std::string& getSender() const { return _sender; }
        const std::string& getRecipient() const { return _recipient; }
        const std::string& getQuotedWeakClient() const { return _weakclient; }

        const std::string& getMember(TripletMember m) const throw (std::out_of_range){
                switch(m) {
                        case TM_sender:
                                return _sender;
                        case TM_recipient:
                                return _recipient;
                        case TM_client:
                                return _client_address;
                        case TM_resolved:
                                return _resolved;
                        case TM_quotedweakclient:
                                return getQuotedWeakClient();
                        default:
                                throw std::out_of_range( "Triplet::getMember out of range" );                   
                }
        }
private:
        void _init();

        std::string _client_address;
        std::string _sender;
        std::string _recipient;
        std::string _resolved;
        std::string _client_address_numeric; //not pretty
        std::string _not_resolved;
        std::string _weakclient;
};
class WLCompare
{
public:
        const char* _compareWith;
        const char* _compareOp;
        Triplet::TripletMember _tripletMember;
        const char* _compareBinder;
};
typedef WLCompare WLCompares[MAX_WL_COMPARES];

#endif

---