vcard.h

/*
  Copyright (c) 2006-2009 by Jakob Schroeter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/


#ifndef VCARD_H__
#define VCARD_H__

#include "gloox.h"
#include "stanzaextension.h"

namespace gloox
{

  class Tag;

  class GLOOX_API VCard : public StanzaExtension
  {
    public:
      enum AddressType
      {
        AddrTypeHome   =      1,    
        AddrTypeWork   =      2,    
        AddrTypePref   =      4,    
        AddrTypeX400   =      8,    
        AddrTypeInet   =     16,    
        AddrTypeParcel =     32,    
        AddrTypePostal =     64,    
        AddrTypeDom    =    128,    
        AddrTypeIntl   =    256,    
        AddrTypeVoice  =    512,    
        AddrTypeFax    =   1024,    
        AddrTypePager  =   2048,    
        AddrTypeMsg    =   4096,    
        AddrTypeCell   =   8192,    
        AddrTypeVideo  =  16384,    
        AddrTypeBbs    =  32768,    
        AddrTypeModem  =  65536,    
        AddrTypeIsdn   = 131072,    
        AddrTypePcs    = 262144     
      };

      struct Name
      {
        std::string family;         
        std::string given;          
        std::string middle;         
        std::string prefix;         
        std::string suffix;         
      };

      enum VCardClassification
      {
        ClassNone         = 0,      
        ClassPublic       = 1,      
        ClassPrivate      = 2,      
        ClassConfidential = 4       
      };

      struct Email
      {
        std::string userid;         
        bool home;                  
        bool work;                  
        bool internet;              
        bool pref;                  
        bool x400;                  
      };

      typedef std::list<Email> EmailList;

      struct Telephone
      {
        std::string number;         
        bool home;                  
        bool work;                  
        bool voice;                 
        bool fax;                   
        bool pager;                 
        bool msg;                   
        bool cell;                  
        bool video;                 
        bool bbs;                   
        bool modem;                 
        bool isdn;                  
        bool pcs;                   
        bool pref;                  
      };

      typedef std::list<Telephone> TelephoneList;

      struct Address
      {
        std::string pobox;          
        std::string extadd;         
        std::string street;         
        std::string locality;       
        std::string region;         
        std::string pcode;          
        std::string ctry;           
        bool home;                  
        bool work;                  
        bool postal;                
        bool parcel;                
        bool pref;                  
        bool dom;                   
        bool intl;                  
      };

      struct Label
      {
        StringList lines;           
        bool home;                  
        bool work;                  
        bool postal;                
        bool parcel;                
        bool pref;                  
        bool dom;                   
        bool intl;                  
      };

      struct Geo
      {
        std::string latitude;       
        std::string longitude;      
      };

      struct Org
      {
        std::string name;           
        StringList units;           
      };

      struct Photo
      {
        std::string extval;         
        std::string binval;         
        std::string type;           
      };

      typedef std::list<Address> AddressList;

      typedef std::list<Label> LabelList;

      VCard();

      VCard( const Tag* vcard );

      virtual ~VCard() {}

      void setFormattedname( const std::string& name ) { m_formattedname = name; }

      const std::string& formattedname() const { return m_formattedname; }

      void setName( const std::string& family, const std::string& given,
                    const std::string& middle = EmptyString,
                    const std::string& prefix = EmptyString,
                    const std::string& suffix = EmptyString );

      const Name& name() const { return m_name; }

      void setNickname( const std::string& nickname ) { m_nickname = nickname; }

      const std::string& nickname() const { return m_nickname; }

      void setUrl( const std::string& url ) { m_url = url; }

      const std::string& url() const { return m_url; }

      void setBday( const std::string& bday ) { m_bday = bday; }

      const std::string& bday() const { return m_bday; }

      void setJabberid( const std::string& jabberid ) { m_jabberid = jabberid; }

      const std::string& jabberid() const { return m_jabberid; }

      void setTitle( const std::string& title ) { m_title = title; }

      const std::string& title() const { return m_title; }

      void setRole( const std::string& role ) { m_role = role; }

      const std::string& role() const { return m_role; }

      void setNote( const std::string& note ) { m_note = note; }

      const std::string& note() const { return m_note; }

      void setDesc( const std::string& desc ) { m_desc = desc; }

      const std::string& desc() const { return m_desc; }

      void setMailer( const std::string& mailer ) { m_mailer = mailer; }

      const std::string& mailer() const { return m_mailer; }

      void setRev( const std::string& rev ) { m_rev = rev; }

      const std::string& rev() const { return m_rev; }

      void setUid( const std::string& uid ) { m_uid = uid; }

      const std::string& uid() const { return m_uid; }

      void setTz( const std::string& tz ) { m_tz = tz; }

      const std::string& tz() const { return m_tz; }

      void setProdid( const std::string& prodid ) { m_prodid = prodid; }

      const std::string& prodid() const { return m_prodid; }

      void setSortstring( const std::string& sortstring ) { m_sortstring = sortstring; }

      const std::string& sortstring() const { return m_sortstring; }

      void setPhoto( const std::string& extval );

      void setPhoto( const std::string& type = EmptyString, const std::string& binval = EmptyString );

      const Photo& photo() const { return m_photo; }

      void setLogo( const std::string& extval );

      void setLogo( const std::string& type = EmptyString, const std::string& binval = EmptyString );

      const Photo& logo() const { return m_logo; }

      void addEmail( const std::string& userid, int type );

      EmailList& emailAddresses() { return m_emailList; }

      void addAddress( const std::string& pobox, const std::string& extadd,
                       const std::string& street, const std::string& locality,
                       const std::string& region, const std::string& pcode,
                       const std::string& ctry, int type );

      void addLabel( const StringList& lines, int type );

      AddressList& addresses() { return m_addressList; }

      LabelList& labels() { return m_labelList; }

      void addTelephone( const std::string& number, int type );

      TelephoneList& telephone() { return m_telephoneList; }

      void setGeo( const std::string& lat, const std::string& lon );

      const Geo& geo() const { return m_geo; }

      void setOrganization( const std::string& orgname, const StringList& orgunits );

      const Org& org() const { return m_org; }

      void setClass( VCardClassification vclass ) { m_class = vclass; }

      VCardClassification classification() const { return m_class; }

      // reimplemented from StanzaExtension
      virtual const std::string& filterString() const;

      // reimplemented from StanzaExtension
      virtual StanzaExtension* newInstance( const Tag* tag ) const
      {
        return new VCard( tag );
      }

      // reimplemented from StanzaExtension
      virtual Tag* tag() const;

      // reimplemented from StanzaExtension
      virtual StanzaExtension* clone() const
      {
        return new VCard( *this );
      }

    private:

      static void insertField( Tag* vcard, const char* field, const std::string& var );
      static void insertField( Tag* vcard, const char* field, bool var );
      static void checkField ( const Tag* vcard, const char* field, std::string& var );

      EmailList m_emailList;
      TelephoneList m_telephoneList;
      AddressList m_addressList;
      LabelList m_labelList;

      Name m_name;
      Geo m_geo;
      Org m_org;
      Photo m_photo;
      Photo m_logo;

      VCardClassification m_class;

      std::string m_formattedname;
      std::string m_nickname;
      std::string m_url;
      std::string m_bday;
      std::string m_jabberid;
      std::string m_title;
      std::string m_role;
      std::string m_note;
      std::string m_desc;
      std::string m_mailer;
      std::string m_tz;
      std::string m_prodid;
      std::string m_rev;
      std::string m_sortstring;
      std::string m_uid;

      bool m_N;
      bool m_PHOTO;
      bool m_LOGO;
  };

}

#endif // VCARD_H__