sipfrom.cxx

SIP（Session Initiation Protocol）是由IETF定义

        tokenMap[copy] = copy2;
    }
}


void
SipFrom::parse( const Data& fromdata)
{

    Data data = fromdata;

    try
    {

        scanSipFrom(data);
    }
    catch (SipFromParserException& exception)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Decode in Constructor :o( ");

            throw SipFromParserException(
                exception.getDescription(),
                __FILE__,
                __LINE__, DECODE_FROM_FAILED
            );
        }
    }


    //everything allright.


}


void
SipFrom::decode( const Data& fromstr )
{

    try
    {
        parse(fromstr);
    }
    catch (SipFromParserException&)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Decode in Constructor :o( ");

            throw SipFromParserException(
                "Parser Exception",
                __FILE__,
                __LINE__, DECODE_FROM_FAILED);
        }
    }
}


const bool 
SipFrom::operator<(const SipFrom& srcFrom) const
{
    bool urlLess = false;
    if ( (fromUrl != 0) && (srcFrom.fromUrl != 0) )
    {
	urlLess = ( fromUrl->isLessThan(srcFrom.fromUrl));
    }
    else if ( (fromUrl == 0) && (srcFrom.fromUrl != 0) )
    {
	urlLess = true;
    }
    if (urlLess  ||
        (tag < srcFrom.tag) ||
        (token < srcFrom.token) ||
        (qstring < srcFrom.qstring)
    )
    {
        return true;
    }
    return false;
}


bool 
SipFrom::operator>(const SipFrom& srcFrom) const
{
    return (srcFrom < *this);
}


bool 
SipFrom::operator ==(const SipFrom& srcFrom) const
{
    bool equal = false;

    if ( (fromUrl != 0) && (srcFrom.fromUrl != 0) )
    {
        equal = (fromUrl->areEqual(srcFrom.fromUrl));
    }
    else if ( (fromUrl == 0) && (srcFrom.fromUrl == 0) )
    {
	equal = true;
    }
    else
    {
        equal = false;
    }

    cpLog(LOG_DEBUG_STACK, " from urls match result: %s", 
          (equal ? "==" : "!=") );
    equal = (equal && (tag == srcFrom.tag));

    cpLog(LOG_DEBUG_STACK, " tags match result: %s", (equal ? "==" : "!=") );

    equal = (equal && (tokenMap == srcFrom.tokenMap));
    cpLog(LOG_DEBUG_STACK, "tokenMap match result: %s", 
          (equal ? "==" : "!=") );

    cpLog(LOG_DEBUG_STACK, "final result of From operator == is: %s ",
          ( equal ? "true" : "false" ) );
    return equal;
}


int
SipFrom::getPort() const
{
    int port=0;
    
    if (fromUrl != 0)
    {
	if (fromUrl->getType() == SIP_URL)
	{
	    Sptr<SipUrl> sipUrl;
	    sipUrl.dynamicCast(fromUrl);
	    port = sipUrl->getPort().convertInt();
	}

    }
    return port;
}

    
void
SipFrom::setPort(const Data& newport)
{
    if (urlType == TEL_URL)
    {
	return;
    }
    if (fromUrl == 0)
    {
	fromUrl = new SipUrl(false);
    }
    if (fromUrl != 0)
    {
	if (fromUrl->getType() == SIP_URL)
	{
	    Sptr<SipUrl> sipUrl;
	    sipUrl.dynamicCast(fromUrl);
	    sipUrl->setPort(newport);
	}

    }
}


Data SipFrom::encode() const
{
    //assign to data, and return.
    Data sipFrom;
    
    if (fromUrl != 0)
    {
	sipFrom = FROM;
	sipFrom += SP;
	Data dispName = getDisplayName();
        sipFrom += dispName;
	sipFrom += "<";
	sipFrom += fromUrl->encode();
	sipFrom+= ">";
    }
    
    Data tagparam = getTag();
    if (tagparam.length() > 0)
    {
        sipFrom += ";";
        sipFrom += "tag=";
        sipFrom += tagparam;
    }
    TokenMapFrom::const_iterator i = tokenMap.begin();
    if (i != tokenMap.end())
    {
        sipFrom += ";";
    }
    while (i != tokenMap.end())
    {
        Data token1 = i->first;
        Data tokenValue1 = i->second;
        sipFrom += token1;
        if (tokenValue1.length() > 0)
        {
            sipFrom += "=";
            sipFrom += tokenValue1;
        }

        ++i;

        if ( i != tokenMap.end())
        {
            sipFrom += ";";
        }
    }  //end while
    //other than basic

    sipFrom += CRLF;
    
    return sipFrom;
}


void 
SipFrom::setTokenDetails(const Data& intoken, const Data& tokenValue)
{
    tokenMap[intoken] = tokenValue;
}


Sptr < SipFrom::TokenMapFrom >
SipFrom::getTokenDetails() const
{
    Sptr < SipFrom::TokenMapFrom > dupMap = new TokenMapFrom(tokenMap) ;

    return dupMap;
}


Data 
SipFrom::getTokenValue(const Data& intoken) const
{
    Data ret;
    TokenMapFrom::const_iterator check = tokenMap.find(intoken);
    if (check != tokenMap.end())
    {
        ret = check -> second;
    }

    return ret;

}


void 
SipFrom::setUser(const Data& newuser)
{
    if (fromUrl == 0)
    {
	if (urlType == SIP_URL)
	{
	    fromUrl = new SipUrl();
	}
	else if (urlType == TEL_URL)
	{
	    fromUrl = new TelUrl();
	}
    }
    //HERE, the user could be user for TelUrl. We need to be able to
    //identify it some how, Maybe, when we form the From empty object, pass this in the constructor.
    
    
    if (fromUrl != 0)
    {
	fromUrl->setUserValue(newuser);
    }
    //display name defaulted to user.
    if (displayName.length() == 0)
    {
        displayName = newuser;
    }
}


Data 
SipFrom::getUser() const
{
    Data user;
    if (fromUrl != 0)
    {
	user = fromUrl->getUserValue();
    }
    return user;
}

    
void 
SipFrom::setDisplayName(const Data& name)
{
    displayName = name;
}

    
const Data& 
SipFrom::getDisplayName() const
{
    return displayName;
}

    
void
SipFrom::setHost(const Data& newhost)
{
    if (urlType == TEL_URL)
    {
	return;
    }
    if (fromUrl == 0)
    {
	fromUrl = new SipUrl();
    }
    if (fromUrl != 0)
    {
    	if (fromUrl->getType() == SIP_URL)
	{
	    Sptr<SipUrl> sipUrl;
	    sipUrl.dynamicCast(fromUrl);
	    sipUrl->setHost(newhost);
	}
    }
}


Data
SipFrom::getHost() const
{
    Data host;
    if (fromUrl != 0)
    {
    	if (fromUrl->getType() == SIP_URL)
	{
	    Sptr<SipUrl> sipUrl;
	    sipUrl.dynamicCast(fromUrl);
	    host = sipUrl->getHost();
	}
    }
    return host;
}


const Data&
SipFrom::getTag() const
{
    return tag;
}


void
SipFrom::setTag( const Data& newtag )
{
    tag = newtag;
}


Sptr <BaseUrl>
SipFrom::getUrl() const
{
    return duplicateUrl(fromUrl, true);
}


void
SipFrom::setUrl( Sptr <BaseUrl> newfromUrl )
{
    fromUrl = duplicateUrl(newfromUrl);
}


SipHeader*
SipFrom::duplicate() const
{
    return new SipFrom(*this);
}


bool
SipFrom::compareSipHeader(SipHeader* msg) const
{
    SipFrom* otherMsg = dynamic_cast<SipFrom*>(msg);
    if(otherMsg != 0)
    {
	return (*this == *otherMsg);
    }
    else
    {
	return false;
    }
}


/* Local Variables: */
/* c-file-style: "stroustrup" */
/* indent-tabs-mode: nil */
/* c-file-offsets: ((access-label . -) (inclass . ++)) */
/* c-basic-offset: 4 */
/* End: */