address.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.4 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _ADDRESS_H_
#define _ADDRESS_H_

// ************************************************************************
// included header files
// + standard includes
#include <set>
#include <string>
#include <vector>
#include <map>

// + libraries

// + local headers
#include "osbid.h"

// + class declarations
namespace OSB_DB {
    class AddressGw;
    class Session;
}

namespace OSB_LIB {
    class Associate;
}

// ************************************************************************
// namespace extensions
namespace OSB_LIB {

// ************************************************************************
// forward declarations

// ************************************************************************
// type definitions
    enum AddressType
    {
        atUnknown  = 0x0000,
        atBilling  = 0x0001,
        atHome     = 0x0002,
        atOffice   = 0x0004
    };

    inline AddressType addressType(unsigned long);

// ************************************************************************
// class definitions

    // *****************************************************************
    // Address
    class Address {
        friend class OSB_DB::AddressGw;
        friend class Associate;

    public:
        typedef Id<Associate> OwnerId;

    public:
        typedef std::set<AddressType> TypeList;

        Address(
            const OwnerId&  ownerId,
            const TypeList& types
        );


        inline const OwnerId&     ownerId()   const;
        inline const TypeList&    types()     const;
        inline const std::string& addressee() const;
        inline const std::string& street()    const;
        inline const std::string& city()      const;
        inline const std::string& state()     const;
        inline const std::string& zipcode()   const;
        inline const std::string& country()   const;
        inline const std::string& telNum()    const;
        inline const std::string& email()     const;
        inline const std::string& faxNum()    const;
        inline const std::string& function()  const;


        void setAddressee(const std::string& addressee);
        void setStreet(const std::string& street);
        void setCity(const std::string& city);
        void setState(const std::string& state);
        void setZipcode(const std::string& zip);
        void setCountry(const std::string& country);
        void setTelNum(const std::string& tel);
        void setEmail(const std::string& email);
        void setFaxNum(const std::string& fax);
        void setFunction(const std::string& function);

    private:
        bool insert(const OSB_DB::Session& session) const;

        bool update(const OSB_DB::Session& session) const;

        bool remove(const OSB_DB::Session& session) const;

        bool addType(
            const OSB_DB::Session& session,
                  AddressType            type
        );

        bool delType(
            const OSB_DB::Session& session,
                  AddressType            type
        );

        bool contains(AddressType type) const;

    private:
        OwnerId     ownerId_;           
        TypeList    types_;             
        std::string addressee_;         
        std::string street_;            
        std::string city_;              
        std::string state_;             
        std::string zipcode_;           
        std::string country_;           
        std::string telNum_;            
        std::string email_;             
        std::string faxNum_;            
        std::string function_;          
    };                                  // class Address

    typedef std::vector<Address>  AddressList;


    struct AddressTypeInfo {
        AddressType type;
        std::string name;
    };

    // *****************************************************************
    // AddressTypeList
    class AddressTypeList {
    public:


        typedef std::map<AddressType, AddressTypeInfo> List;
        typedef List::iterator Iterator;
        typedef List::const_iterator ConstIterator;
        typedef List::size_type SizeType;
        typedef List::key_type KeyType;

        const List& list() const { return list_; }


        Iterator begin() { return list_.begin(); }
        Iterator end() { return list_.end(); }
        Iterator find(const KeyType& k) { return list_.find(k); }
        ConstIterator begin() const { return list_.begin(); }
        ConstIterator end() const { return list_.end(); }
        ConstIterator find(const KeyType& k) const
        { return list_.find(k); }
        SizeType size() const { return list_.size(); }

        long read(const OSB_DB::Session& session);

        const AddressTypeInfo* findAddressType(
            AddressType typeId
        ) const;

        const AddressTypeInfo& getAddressType(
            AddressType typeId
        ) const;

    private:
        List list_;
    };                                  // class AddressTypeList

    // *****************************************************************
    // TheAddressTypeList
    class TheAddressTypeList {
    public:
        static AddressTypeList& instance();

    private:
        TheAddressTypeList();
        TheAddressTypeList(const TheAddressTypeList& rhs);

        static AddressTypeList* instance_;
    };                                  // TheAddressTypeList
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
    // ********************************************************************
    // AddressType
    inline AddressType addressType(unsigned long at)
    {
        switch (at) {
            case 0x0001: return atBilling;
            case 0x0002: return atHome;
            case 0x0004: return atOffice;
        }
        return AddressType(atUnknown);
    }

    inline long toLong(AddressType at)
    {
        long rc = at;
        switch (rc) {
            case atBilling:
            case atHome:
            case atOffice:   break;
            default:  rc = atUnknown;   // ToDo: remove
        }
        return rc;
    }

    // *****************************************************************
    // Address
    inline const Address::OwnerId& Address::ownerId() const
    {
        return ownerId_;
    }

    inline const Address::TypeList& Address::types() const
    {
        return types_;
    }

    inline const std::string& Address::addressee() const
    {
        return addressee_;
    }

    inline const std::string& Address::street() const
    {
        return street_;
    }

    inline const std::string& Address::city() const
    {
        return city_;
    }

    inline const std::string& Address::state() const
    {
        return state_;
    }

    inline const std::string& Address::zipcode() const
    {
        return zipcode_;
    }

    inline const std::string& Address::country() const
    {
        return country_;
    }

    inline const std::string& Address::telNum() const
    {
        return telNum_;
    }

    inline const std::string& Address::email() const
    {
        return email_;
    }

    inline const std::string& Address::faxNum() const
    {
        return faxNum_;
    }

    inline const std::string& Address::function() const
    {
        return function_;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _ADDRESS_H_

---