mpitems.h

一个SIP协议栈

        virtual void           decode(const std::mstring & str, bool chk_syntax_flag=true);
        virtual void           checkSyntax() const;
        virtual void           erase();
        virtual bool           empty() const;
        virtual MpParseItem &  operator [] (const char * name);
        virtual std::mstring & val(const char * name);
        virtual unsigned       valCount() const { return 2; }
        virtual unsigned       itemCount() const { return 1; }
        virtual void           get(unsigned i, std::mstring *name, std::mstring *value) const;
        virtual MpParseItem &  item(unsigned i, std::mstring *name);

        void operator = (const std::mstring & str) { decode(str); }

        ///Get Reason Phrase Text
        static const char * getReasonPhrase(MpResponseCode code);

        ///Get Method String
        static const char * getMethodString(MpMsgType type);

        ///Get Method Type By Name
        static MpMsgType getMethod(const std::string &method);

        ///Get Method
        MpMsgType getMethod() const { return getMethod(mp_Type); }

    private:
        MpStartLine(const MpStartLine &);
        MpStartLine & operator = (const MpStartLine &);
    };





    /**Value and parameters common abstract item
     * val_parm.val(mpnValue)
     * val_parm.val(mpnSubVal)
     * val_parm[mpiParm].val(...)
     */
    class MpValParm : public MpHeader
    {
        std::mstring mp_Value;
        std::mstring mp_SubVal;
        MpParm       mp_Parm;
        const char   mp_Separator;

    protected:
        MpValParm(char sep) 
        : mp_Parm('=', ';', ';', 0, true, ""),
          mp_Separator(sep)
        {}

    public:
        virtual ~MpValParm() {}

        virtual std::mstring   encode(bool chk_syntax_flag=true) const;
        virtual void           decode(const std::mstring & str, bool chk_syntax_flag=true);
        virtual void           checkSyntax() const;
        virtual void           erase() { mp_Value.erase(); mp_SubVal.erase(); mp_Parm.erase(); }
        virtual bool           empty() const { return mp_Value.empty(); }
        virtual MpParseItem &  operator [] (const char * name);
        virtual std::mstring & val(const char * name);
        virtual unsigned       valCount() const { return 2; }
        virtual unsigned       itemCount() const { return 1; }
        virtual void           get(unsigned i, std::mstring *name, std::mstring *value) const;
        virtual MpParseItem &  item(unsigned i, std::mstring *name);

        void operator = (const std::mstring & str) { decode(str); }

    private:
        MpValParm(const MpValParm &);
        MpValParm & operator = (const MpValParm &);
    };



    /**Accept Header
     * accept.val(mpnValue)
     * accept.val(mpnSubVal)
     * accept[mpiParm].val(...)
     */
    class MpAccept : public MpValParm
    {
    public:
        MpAccept() : MpValParm('/')
        { setHeaderInfo(hdrnAccept, true, true); }
        virtual ~MpAccept() {}
        virtual MpHeader *    clone() const { return new MpAccept; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpAccept(const MpAccept &);
        MpAccept & operator = (const MpAccept &);
    };


    /**Content-Type Header
     * cont_type.val(mpnValue)
     * cont_type.val(mpnSubVal)
     * cont_type[mpiParm].val(...)
     */
    class MpContentType : public MpValParm
    {
    public:
        MpContentType() : MpValParm('/')
        { setHeaderInfo(hdrnContentType, false, false); }
        virtual ~MpContentType() {}
        virtual MpHeader *    clone() const { return new MpContentType; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpContentType(const MpContentType &);
        MpContentType & operator = (const MpContentType &);
    };



    /**Accept-Language Header
     * acpt_lang.val(mpnValue)
     * acpt_lang[mpiParm].val(...)
     */
    class MpAcceptLanguage : public MpValParm
    {
    public:
        MpAcceptLanguage() : MpValParm(0) 
        { setHeaderInfo(hdrnAcceptLanguage, true, true); }
        virtual ~MpAcceptLanguage() {}
        virtual MpHeader * clone() const { return new MpAcceptLanguage; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpAcceptLanguage(const MpAcceptLanguage &);
        MpAcceptLanguage & operator = (const MpAcceptLanguage &);
    };



    /**Values only common abstract item (without any parameters)
     * value.val(mpnValue)
     * value.val(...)
     */
    class MpValue : public MpHeader
    {
        std::mstring mp_Value[16];
        const char * mp_Name[16];
        bool         mp_Quoted[16];
        unsigned     mp_NVal;
        char         mp_Separator;

    public:
        MpValue(char sep=0);
        virtual ~MpValue() {}
        void set_val_name(unsigned index, const char * name, bool quoted=false);

        virtual MpHeader *     clone() const;
        virtual std::mstring   encode(bool chk_syntax_flag=true) const;
        virtual void           decode(const std::mstring & str, bool chk_syntax_flag=true);
        virtual void           checkSyntax() const {}
        virtual void           erase() { mp_Value[0].erase(); }
        virtual bool           empty() const { return mp_Value[0].empty(); }
        virtual MpParseItem &  operator [] (const char * name);
        virtual std::mstring & val(const char * name);
        virtual unsigned       valCount() const { return mp_NVal; }
        virtual void           get(unsigned i, std::mstring *name, std::mstring *value) const;

        void operator = (const std::mstring & str) { decode(str); }

    private:
        MpValue(const MpValue &);
        MpValue & operator = (const MpValue &);
    };
    




    /**Accept-Encoding Header
     * acpt_enc.val(mpnValue)
     */
    class MpAcceptEncoding : public MpValue
    {
    public:
        MpAcceptEncoding() : MpValue() 
        { setHeaderInfo(hdrnAcceptEncoding, true, true); }
        virtual ~MpAcceptEncoding() {}
        virtual MpHeader *    clone() const { return new MpAcceptEncoding; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpAcceptEncoding(const MpAcceptEncoding &);
        MpAcceptEncoding & operator = (const MpAcceptEncoding &);
    };




    /**Allow Header
     * allow.val(mpnValue)
     */
    class MpAllow : public MpValue
    {
    public:
        MpAllow() { setHeaderInfo(hdrnAllow, true, true); }
        virtual ~MpAllow() {}
        virtual MpHeader *    clone() const { return new MpAllow; }
        virtual void checkSyntax() const;
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpAllow(const MpAllow &);
        MpAllow & operator = (const MpAllow &);
    };



    /**Authorization Header !!!May be refined in future
     * auth.val(mpnValue)
     * auth[mpiParm].val(...)
     */
    class MpAuthorization : public MpValParm
    {
    public:
        MpAuthorization() : MpValParm(0)
        { setHeaderInfo(hdrnAuthorization, false, false); }
        virtual ~MpAuthorization() {}
        virtual MpHeader *    clone() const { return new MpAuthorization; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpAuthorization(const MpAuthorization &);
        MpAuthorization & operator = (const MpAuthorization &);
    };


    /**Call-ID Header. 
     * callid[mpiHostPort].val(mpnHost)
     * callid.val(mpnValue)
     */
/*
    class MpCallID : public MpHeader
    {
        std::mstring mp_CallID;
        MpHostPort   mp_HostPort;

    public:
        MpCallID() { setHeaderInfo(hdrnCallID, false, false); }
        virtual ~MpCallID() {}

        virtual MpHeader *     clone() const { return new MpCallID; }
        virtual std::mstring   encode(bool chk_syntax_flag=true) const;
        virtual void           decode(const std::mstring & str, bool chk_syntax_flag=true);
        virtual void           checkSyntax() const;
        virtual void           erase() { mp_CallID.erase(); mp_HostPort.erase(); }
        virtual bool           empty() const { return mp_CallID.empty(); }
        virtual MpParseItem &  operator [] (const char * name);
        virtual std::mstring & val(const char * name);
        virtual unsigned       valCount() const { return 1; }
        virtual unsigned       itemCount() const { return 1; }
        virtual void           get(unsigned i, std::mstring *name, std::mstring *value) const;
        virtual MpParseItem &  item(unsigned i, std::mstring *name);

        void operator = (const std::mstring & str) { decode(str); }

    private:
        MpCallID(const MpCallID &);
        MpCallID & operator = (const MpCallID &);
    };
*/


    /**MpCallID Header
     * callid.val(mpnValue)
     */
    class MpCallID : public MpValue
    {
    public:
        MpCallID() { setHeaderInfo(hdrnCallID, false, false); }
        virtual ~MpCallID() {}
        virtual MpHeader * clone() const { return new MpCallID; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpCallID(const MpCallID &);
        MpCallID & operator = (const MpCallID &);
    };





    /**Name, address, params and comment abstract item
     * mn_addr.val(mpnDispName)
     * mn_addr.val(mpnComment)
     * mn_addr[mpiUrl][...]
     * mn_addr[mpiParm].val(...)
     */
    class MpNameAddrParm : public MpHeader
    {
        std::mstring mp_DispName;
        std::mstring mp_Comment;
        MpUrl        mp_Url;
        MpParm       mp_Parm;

    public:
        MpNameAddrParm(const char * itm_name, const char * allowed_url_prefixes)
        : mp_Parm('=', ';', ';', 0, true, itm_name),
          mp_Url(allowed_url_prefixes)
        {}
        virtual ~MpNameAddrParm() {}

        virtual std::mstring   encode(bool chk_syntax_flag=true) const;
        virtual void           decode(const std::mstring & str, bool chk_syntax_flag=true);
        virtual void           checkSyntax() const;
        virtual void           erase(); 
        virtual bool           empty() const { return mp_Url.empty(); }
        virtual MpParseItem &  operator [] (const char * name);
        virtual std::mstring & val(const char * name);
        virtual unsigned       valCount() const { return 2; }
        virtual unsigned       itemCount() const { return 2; }
        virtual void           get(unsigned i, std::mstring *name, std::mstring *value) const;
        virtual MpParseItem &  item(unsigned i, std::mstring *name);

        void operator = (const std::mstring & str) { decode(str); }

    private:
        MpNameAddrParm(const MpNameAddrParm &);
        MpNameAddrParm & operator = (const MpNameAddrParm &);
    };



    /**Contact Header
     * contact.val(mpnDispName)
     * contact.val(mpnComment)
     * contact[mpiUrl][...]
     * contact[mpiParm].val(...)
     */
    class MpContact : public MpNameAddrParm 
    {
    public:
        MpContact()
        : MpNameAddrParm(mpiContactParm, sipContactAllowedPrefixes) 
        { setHeaderInfo(hdrnContact, true, false); }
        virtual ~MpContact() {}

        virtual MpHeader * clone() const { return new MpContact; }

        void operator = (const std::mstring & str) { decode(str); }

    private:
        MpContact(const MpContact &);
        MpContact & operator = (const MpContact &);
    };


    /**Content-Encoding Header
     * cont_enc.val(mpnValue)
     */
    class MpContentEncoding : public MpValue
    {
    public:
        MpContentEncoding() { setHeaderInfo(hdrnContentEncoding, false, false); }
        virtual ~MpContentEncoding() {}
        virtual MpHeader * clone() const { return new MpContentEncoding; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpContentEncoding(const MpContentEncoding &);
        MpContentEncoding & operator = (const MpContentEncoding &);
    };


    /**Content-Length Header
     * cont_len.val(mpnValue)
     */
    class MpContentLength : public MpValue
    {
    public:
        MpContentLength() { setHeaderInfo(hdrnContentLength, false, false); }
        virtual ~MpContentLength() {}
        virtual MpHeader * clone() const { return new MpContentLength; }
        virtual void checkSyntax() const;
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpContentLength(const MpContentLength &);
        MpContentLength & operator = (const MpContentLength &);
    };



    /**CSeq Header
     * cseq.val(mpnCSeq)
     * cseq.val(mpnMethod)
     */
    class MpCSeq : public MpValue
    {
    public:
        MpCSeq();
        virtual ~MpCSeq() {}
        virtual MpHeader * clone() const { return new MpCSeq; }
        virtual void       checkSyntax() const;
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpCSeq(const MpCSeq &);
        MpCSeq & operator = (const MpCSeq &);
    };



    /**Date Header !!!May be refined in future
     * date.val(mpnValue)
     */
    class MpDate : public MpValue
    {
    public:
        MpDate() { setHeaderInfo(hdrnDate, false, false); }
        virtual ~MpDate() {}
        virtual MpHeader * clone() const { return new MpDate; }
        virtual void       checkSyntax() const;
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpDate(const MpDate &);
        MpDate & operator = (const MpDate &);
    };



    /**Encryption Header !!!May be refined in future
     * enc.val(mpnValue)
     */
    class MpEncryption : public MpValue
    {
    public:
        MpEncryption() { setHeaderInfo(hdrnEncryption, false, false); }
        virtual ~MpEncryption() {}
        virtual MpHeader * clone() const { return new MpEncryption; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpEncryption(const MpEncryption &);
        MpEncryption & operator = (const MpEncryption &);
    };



    /**Expires Header !!!May be refined in future
     * exp.val(mpnValue)
     */
    class MpExpires : public MpValue
    {
    public:
        MpExpires() { setHeaderInfo(hdrnExpires, false, false); }
        virtual ~MpExpires() {}
        virtual MpHeader * clone() const { return new MpExpires; }
        void operator = (const std::mstring & str) { decode(str); }
    private:
        MpExpires(const MpExpires &);
        MpExpires & operator = (const MpExpires &);
    };



    /**From Header
     * from.val(mpnDispName)
     * from.val(mpnComment)
     * from[mpiUrl][...]
     * from[mpiParm].val(...)