DialogInfoContents.hxx

Go to the documentation of this file.

#if !defined(RESIP_DialogInfoContents_HXX)
#define RESIP_DialogInfoContents_HXX 
 
#include <map>
#include <list>
 
#include "resip/stack/Contents.hxx"
#include "rutil/Data.hxx"
#include "rutil/HashMap.hxx"
#include "resip/stack/Uri.hxx"
#include "rutil/HeapInstanceCounter.hxx"
 
namespace resip
{
 
class XMLCursor;
 
class DialogInfoContents : public Contents
{
public:
 
   enum DialogInfoState
   {
      Full,
      Partial,
      MaxDialogInfoState
   };
   // Warning if you modify the above list, make sure you modify DialogInfoStateStrings in the .cxx file to match
 
   enum DialogState
   {
      Trying = 0,
      Proceeding,
      Early,
      Confirmed,
      Terminated,
      MaxDialogState
   };
   // Warning if you modify the above list, make sure you modify DialogStateStrings in the .cxx file to match
 
   enum DialogStateEvent
   {
      Cancelled = 0,
      Rejected,
      Replaced,
      LocalBye,
      RemoteBye,
      Error,
      Timeout,
      MaxOrUnsetDialogStateEvent
   };
   // Warning if you modify the above list, make sure you modify DialogStateEventStrings in the .cxx file to match
 
   enum Direction
   {
      Initiator = 0,
      Recipient,
      MaxOrUnsetDirection
   };
   // Warning if you modify the above list, make sure you modify DialogStateEventStrings in the .cxx file to match
 
   static const DialogInfoContents Empty;
 
   RESIP_HeapCount(DialogInfoContents);
   DialogInfoContents(const Mime& contentType);
   DialogInfoContents();
   DialogInfoContents(const HeaderFieldValue& hfv, const Mime& contentType);
   virtual ~DialogInfoContents();
 
   virtual Contents* clone() const;
   static const Mime& getStaticType();
   virtual EncodeStream& encodeParsed(EncodeStream& str) const;
   virtual void parse(ParseBuffer& pb);
 
   // Default is 3 spaces "   "
   void setEncodeIndent(const Data& indent) { mIndent = indent; }
 
   // Accesors for data
   void setEntity(const Uri& entity) { checkParsed(); mEntity = entity; }
   const Uri& getEntity() const { checkParsed(); return mEntity; }
 
   void setVersion(uint32_t version) { checkParsed(); mVersion = version; }
   uint32_t getVersion() const { checkParsed(); return mVersion; }
 
   void setDialogInfoState(DialogInfoState dialogInfoState) { checkParsed(); mDialogInfoState = dialogInfoState; }
   DialogInfoState getDialogInfoState() const { checkParsed(); return mDialogInfoState; }
 
   // A DialogInfoContents can have multiple Dialog sections in it
   class Dialog
   {
   public:
      class DialogIdInfo
      {
      public:
         DialogIdInfo() {}
         DialogIdInfo(const Data& callId, const Data& localTag, const Data& remoteTag) :
            mCallId(callId), mLocalTag(localTag), mRemoteTag(remoteTag) {}
         Data mCallId;
         Data mLocalTag;
         Data mRemoteTag;
      };
 
      Dialog() : mDirection(MaxOrUnsetDirection), mState(Trying), mStateEvent(MaxOrUnsetDialogStateEvent), mStateCode(0), mDuration(0),
         mHasDuration(false), mAppearance(0), mHasAppearance(false), mExclusive(false), mHasExclusive(false) {}
 
      // Accesors for data
      void setId(const Data& id) { mId = id; }
      const Data& getId() const { return mId; }
 
      void setCallId(const Data& callId) { mCallId = callId; }
      const Data& getCallId() const { return mCallId; }
 
      void setLocalTag(const Data& localTag) { mLocalTag = localTag; }
      const Data& getLocalTag() const { return mLocalTag; }
 
      void setRemoteTag(const Data& remoteTag) { mRemoteTag = remoteTag; }
      const Data& getRemoteTag() const { return mRemoteTag; }
 
      void setDirection(const Direction& direction) { mDirection = direction; }
      const Direction& getDirection() const { return mDirection; }
 
      void setState(const DialogState& state) { mState = state; }
      const DialogState& getState() const { return mState; }
 
      void setStateEvent(const DialogStateEvent& stateEvent) { mStateEvent = stateEvent; }
      const DialogStateEvent& getStateEvent() const { return mStateEvent; }
 
      void setStateCode(const int& stateCode) { mStateCode = stateCode; }
      const int& getStateCode() const { return mStateCode; }
 
      void setDuration(const uint32_t& duration) { mDuration = duration; mHasDuration = true; }
      void clearDuration() { mDuration = 0; mHasDuration = false; }
      bool hasDuration() const { return mHasDuration; }
      const uint32_t& getDuration() const { return mDuration; }
 
      void setReplacesInfo(const Data& callId, const Data& localTag, const Data& remoteTag) 
         { mReplaces.mCallId = callId; mReplaces.mLocalTag = localTag; mReplaces.mRemoteTag = remoteTag; }
      const Dialog::DialogIdInfo& getReplaces() const { return mReplaces; }
      const Data& getReplacesCallId() const { return mReplaces.mCallId; }
      const Data& getReplacesLocalTag() const { return mReplaces.mLocalTag; }
      const Data& getReplacesRemoteTag() const { return mReplaces.mRemoteTag; }
 
      void setReferredBy(const NameAddr& referredBy) { mReferredBy = referredBy; }
      const NameAddr& getReferredBy() const { return mReferredBy; }
 
      void addRouteToRouteSet(const NameAddr& route) { mRouteSet.push_back(route); }
      void setRouteSet(const NameAddrs& routes) { mRouteSet = routes; }
      void clearRouteSet() { mRouteSet.clear(); }
      const NameAddrs& getRouteSet() const { return mRouteSet; }
 
      // RFC7463 Elements
      void setAppearance(unsigned int appearanceNum) { mAppearance = appearanceNum; mHasAppearance = true; }
      void clearAppearance() { mAppearance = 0; mHasAppearance = false; }
      bool hasAppearance() const { return mHasAppearance; }
      bool getAppearance() const { return mAppearance; }
 
      void setExclusive(bool exclusive) { mExclusive = exclusive; mHasExclusive = true; }
      void clearExclusive() { mExclusive = false; mHasExclusive = false; }
      bool hasExclusive() const { return mHasExclusive; }
      bool getExclusive() const { return mExclusive; }
 
      void addReplacedDialog(const Data& callId, const Data& localTag, const Data& remoteTag)
         { mReplacedDialogs.push_back(DialogIdInfo(callId, localTag, remoteTag)); }
      void addReplacedDialog(const Dialog::DialogIdInfo& dialogIdInfo) { mReplacedDialogs.push_back(dialogIdInfo); }
      void clearReplacedDialogs() { mReplacedDialogs.clear(); }
      const std::list<Dialog::DialogIdInfo>& getReplacedDialogs() const { return mReplacedDialogs; }
 
      void addJoinedDialog(const Data& callId, const Data& localTag, const Data& remoteTag)
         { mJoinedDialogs.push_back(DialogIdInfo(callId, localTag, remoteTag)); }
      void addJoinedDialog(const Dialog::DialogIdInfo& dialogIdInfo) { mJoinedDialogs.push_back(dialogIdInfo); }
      void clearJoinedDialogs() { mJoinedDialogs.clear(); }
      const std::list<Dialog::DialogIdInfo>& getJoinedDialogs() const { return mJoinedDialogs; }
 
      class Participant
      {
      public:
         Participant() : mCSeq(0), mHasCSeq(false) {}
 
         void setIdentity(const NameAddr& identity) { mIdentity = identity; }
         const NameAddr& getIdentity() const { return mIdentity; }
 
         void setTarget(const Uri& target) { mTarget = target; }
         void setTarget(const NameAddr& targetWithContactParams);
         const Uri& getTarget() const { return mTarget; }
 
         typedef std::map<Data, Data> TargetParams;
         void addTargetParam(const Data& name, const Data& value) { mTargetParams[name] = value; }
         void clearTargetParams() { mTargetParams.clear(); }
         const TargetParams& getTargetParams() const { return mTargetParams; }
         bool getTargetParam(const Data& name, Data& value) const;
 
         void setSessionDescription(const Data& sessionDescription, const Data& sessionDescriptionType)
            {  mSessionDescription = sessionDescription; mSessionDescriptionType = sessionDescriptionType; }
         const Data& getSessionDescription() const { return mSessionDescription; }
         const Data& getSessionDescriptionType() const { return mSessionDescriptionType; }
 
         void setCSeq(const uint32_t& cseq) { mCSeq = cseq; mHasCSeq = true; }
         void clearCSeq() { mCSeq = 0; mHasCSeq = false; }
         bool hasCSeq() const { return mHasCSeq; }
         const uint32_t& getCSeq() const { return mCSeq; }
 
      private:
         NameAddr mIdentity;
         Uri mTarget;
         TargetParams mTargetParams;
         Data mSessionDescription;
         Data mSessionDescriptionType;
         uint32_t mCSeq;
         bool mHasCSeq;
 
         friend class Dialog;
         friend class DialogInfoContents;
         EncodeStream& encode(EncodeStream& str, const char* baseElementName, const Data& indent) const;
         void parse(XMLCursor& xml, const Data& namespacePrefix);
         void parseParam(XMLCursor& xml);
      };
 
      Participant& localParticipant() { return mLocalParticipant; }
      const Participant& localParticipant() const { return mLocalParticipant; }
 
      Participant& remoteParticipant() { return mRemoteParticipant; }
      const Participant& remoteParticipant() const { return mRemoteParticipant; }
 
      // add element name and value to the extra Dialog child elements map
      // These are local/non-standard child elements to the Dialog element
      void addDialogElement(const Data& childElementName, const Data& elementValue) { mExtraDialogElements.insert( std::pair<Data,Data>(childElementName, elementValue));}
 
      // get the instance'th occurance of the named Dialog child element.
      // The first instance is index 0.
      bool getDialogElement(const Data& childElementName, Data& elementValue, int instance=0) const;
 
   private:
      Data mId;
      Data mCallId;
      Data mLocalTag;
      Data mRemoteTag;
      Direction mDirection;
 
      DialogState mState;
      DialogStateEvent mStateEvent;
      int mStateCode;
 
      uint32_t mDuration;
      bool mHasDuration;
 
      DialogIdInfo mReplaces;
 
      NameAddr mReferredBy;
 
      NameAddrs mRouteSet;
 
      Participant mLocalParticipant;
      Participant mRemoteParticipant;
 
      // RFC7463 specific elements
      unsigned int mAppearance;
      bool mHasAppearance;
      bool mExclusive;
      bool mHasExclusive;
      std::list<DialogIdInfo> mReplacedDialogs;
      std::list<DialogIdInfo> mJoinedDialogs;
 
      std::multimap<Data, Data> mExtraDialogElements;
 
      friend class DialogInfoContents;
      EncodeStream& encodeParsed(EncodeStream& str, const Data& indent) const;
   };
 
   typedef std::list<Dialog> DialogList;
   const DialogList& getDialogs() const { checkParsed(); return mDialogs; }
   void addDialog(const Dialog& dialog);
   bool removeDialog(const Data& id);
   void clearDialogs() { checkParsed();  mDialogs.clear(); }
 
   static bool init();
   static const char* dialogInfoStateToString(const DialogInfoState& dialogInfoState);
   static DialogInfoState dialogInfoStateStringToEnum(const Data& dialogInfoStateString);
   static const char* dialogStateToString(const DialogState& dialogState);
   static DialogState dialogStateStringToEnum(const Data& dialogStateString);
   static const char* dialogStateEventToString(const DialogStateEvent& dialogStateEvent);
   static DialogStateEvent dialogStateEventStringToEnum(const Data& dialogStateEventString);
   static const char* directionToString(const Direction& direction);
   static Direction directionStringToEnum(const Data& directionString);
   static bool compareTag(const Data& tagName, const Data& compareToTagNoPrefix, const Data& namespacePrefix);
 
private:
 
   static EncodeStream& encodeNameAddrElement(EncodeStream& str, const char* elementName, const NameAddr& nameAddr);
   void parseDialog(XMLCursor& xml);
   static bool parseDialogIdInfo(XMLCursor& xml, Dialog::DialogIdInfo& dialogIdInfo);
   static bool parseUriValue(XMLCursor& xml, Uri& uri);
   static bool parseNameAddrElement(XMLCursor& xml, NameAddr& nameAddr);
 
   // Base DialogInfoContents data members
   Data mBaseDialogInfoNamespacePrefix;
   Data mSharedAppearanceDialogInfoNamespacePrefix;
   Data mIndent;
   Uri mEntity;
   uint32_t mVersion;
   DialogInfoState mDialogInfoState;
 
   DialogList mDialogs;
};
 
static bool invokeDialogInfoContentsInit = DialogInfoContents::init();
 
}
 
#endif
 
/* ====================================================================
*
* Copyright (c) 2016-2021 SIP Spectrum, Inc. www.sipspectrum.com
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in
*    the documentation and/or other materials provided with the
*    distribution.
*
* 3. Neither the name of the author(s) nor the names of any contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* ====================================================================
*
*/
/*
* vi: set shiftwidth=3 expandtab:
*/