cslabel.c

www工具包. 这是W3C官方支持的www支撑库. 其中提供通用目的的客户端的WebAPI: complete HTTP/1.1 (with caching, pipelining, PUT, POS

	pCSLabel->pCurrentExtension = me;
	if (!pCSLabel->pCurrentLabelOptions->extensions)
		pCSLabel->pCurrentLabelOptions->extensions = HTList_new();
	HTList_appendObject(pCSLabel->pCurrentLabelOptions->extensions, (void *)me);
	return StateRet_OK;
}

PRIVATE StateRet_t Extension_mandatory(CSParse_t * pCSParse, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
	pCSLabel->pCurrentExtension->mandatory = 1;
	pCSLabel->pCSLLData->mandatoryExtensions++;
    return StateRet_OK;
}

PRIVATE StateRet_t Extension_getURL(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
    if (!token || !pCSParse->pParseContext->observedQuotes)
        return StateRet_WARN_NO_MATCH;
    if (Punct_badDemark(pStateToken->validPunctuation, demark))
        return StateRet_WARN_BAD_PUNCT;
    CHECK_CAR_SET(CharSet_URL)
	SVal_readVal(&pCSLabel->pCurrentExtension->url, token);
	return StateRet_OK;
}

PRIVATE StateRet_t Extension_close(CSParse_t * pCSParse, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
	pCSLabel->pCurrentExtension = 0;
	return StateRet_OK;
}

PRIVATE void Extension_destroy(CSParse_t * pCSParse)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
    HTList_removeObject(pCSLabel->pCurrentLabelOptions->extensions, (void *)pCSLabel->pCurrentExtension);
	if (!HTList_count(pCSLabel->pCurrentLabelOptions->extensions)) {
        HTList_delete(pCSLabel->pCurrentLabelOptions->extensions);
        pCSLabel->pCurrentLabelOptions->extensions = 0;
    }
    Extension_free(pCSLabel->pCurrentExtension);
    pCSLabel->pCurrentExtension = 0;
}

PRIVATE StateRet_t Extension_next(CSParse_t * pCSParse, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
    if (pCSLabel->pCurrentSingleLabel) {
        SETNEXTSTATE(&SingleLabel_targetObject, SubState_A);
    } else {
        SETNEXTSTATE(&ServiceInfo_targetObject, SubState_B);
    }
	return StateRet_OK;
}

PRIVATE StateRet_t ExtensionData_open(CSParse_t * pCSParse, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
	ExtensionData_t * me = ExtensionData_new();

	me->pParentExtensionData = pCSLabel->pCurrentExtensionData;
	if(pCSLabel->pCurrentExtensionData) {
		if (!pCSLabel->pCurrentExtensionData->moreData)
			pCSLabel->pCurrentExtensionData->moreData = HTList_new();
		HTList_appendObject(pCSLabel->pCurrentExtensionData->moreData, (void *)me);
	} else {
		if (!pCSLabel->pCurrentExtension->extensionData)
			pCSLabel->pCurrentExtension->extensionData = HTList_new();
		HTList_appendObject(pCSLabel->pCurrentExtension->extensionData, (void *)me);
	}
	pCSLabel->pCurrentExtensionData = me;
	return StateRet_OK;
}

PRIVATE StateRet_t ExtensionData_next(CSParse_t * pCSParse, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
	/* close has already set recursed to the parentExtensionData */
    if (pCSLabel->pCurrentExtensionData) {
        SETNEXTSTATE(&ExtensionData_targetObject, SubState_B);
    } else {
        SETNEXTSTATE(&Extension_targetObject, SubState_C);
    }
    return StateRet_OK;
}

PRIVATE StateRet_t ExtensionData_close(CSParse_t * pCSParse, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
    pCSLabel->pCurrentExtensionData = pCSLabel->pCurrentExtensionData->pParentExtensionData;
    return StateRet_OK;
}

PRIVATE void ExtensionData_destroy(CSParse_t * pCSParse)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
    HTList ** pHolderList = pCSLabel->pCurrentExtensionData->pParentExtensionData ? 
                            &pCSLabel->pCurrentExtensionData->pParentExtensionData->moreData : 
                            &pCSLabel->pCurrentExtension->extensionData;
    HTList_removeObject(*pHolderList, (void *)pCSLabel->pCurrentExtensionData);
	if (!HTList_count(*pHolderList)) {
        HTList_delete(*pHolderList);
        *pHolderList = 0;
    }
    ExtensionData_free(pCSLabel->pCurrentExtensionData);
    pCSLabel->pCurrentExtensionData = 0;
}

PRIVATE StateRet_t ExtensionData_getData(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSLabel_t * pCSLabel = GetCSLabel(pCSParse);
	ExtensionData_t * me;
    if (!token)
        return StateRet_WARN_NO_MATCH;
    if (Punct_badDemark(pStateToken->validPunctuation, demark))
        return StateRet_WARN_BAD_PUNCT;
    CHECK_CAR_SET(CharSet_EXT_DATA)
	me = pCSLabel->pCurrentExtensionData;
/*    SVal_readVal(&me->text, token); */
	StrAllocCopy(me->text, token);
	me->quoted = pCSParse->pParseContext->observedQuotes;
	return StateRet_OK;
}
#if 0
PRIVATE StateRet_t LabelRating_doClose(CSParse_t * pCSParse, char * token, char demark)
{
    if (pCSParse->pParseContext->pTargetChangeCallback && 
		(*pCSParse->pParseContext->pTargetChangeCallback)(pCSParse, &LabelRating_targetObject, CSLLTC_RATING, 2) == StateRet_ERROR)
			return NowIn_ERROR;
    return LabelRating_close(pCSParse, token, demark);
}
#endif
PRIVATE StateRet_t SingleLabel_doClose(CSParse_t * pCSParse, char * token, char demark)
{
    if (pCSParse->pParseContext->pTargetChangeCallback && 
       	(*pCSParse->pParseContext->pTargetChangeCallback)(pCSParse, &SingleLabel_targetObject, CSLLTC_SINGLE, 2, 0) == StateRet_ERROR) /* !!! - pVoid */
			return NowIn_ERROR;
	return SingleLabel_close(pCSParse, token, demark);
}
#if 0
PRIVATE StateRet_t LabelTree_doClose(CSParse_t * pCSParse, char * token, char demark)
{
    if (pCSParse->pParseContext->pTargetChangeCallback && 
		(*pCSParse->pParseContext->pTargetChangeCallback)(pCSParse, &LabelTree_targetObject, CSLLTC_LABTREE, 2) == StateRet_ERROR)
			return NowIn_ERROR;
	return LabelTree_close(pCSParse, token, demark);
}
#endif
PRIVATE StateRet_t Label_doClose(CSParse_t * pCSParse, char * token, char demark)
{
    if (pCSParse->pParseContext->pTargetChangeCallback && 
       	(*pCSParse->pParseContext->pTargetChangeCallback)(pCSParse, &Label_targetObject, CSLLTC_LABEL, 2, 0) == StateRet_ERROR) /* !!! - pVoid */
			return NowIn_ERROR;
	return Label_close(pCSParse, token, demark);
}
#if 0
PRIVATE StateRet_t ServiceInfo_doClose(CSParse_t * pCSParse, char * token, char demark)
{
    if (pCSParse->pParseContext->pTargetChangeCallback && 
		(*pCSParse->pParseContext->pTargetChangeCallback)(pCSParse, &ServiceInfo_targetObject, CSLLTC_SERVICE, 2) == StateRet_ERROR)
			return NowIn_ERROR;
    return ServiceInfo_close(pCSParse, token, demark);
}
#endif
/* CSParse_doc end */
/* I T E R A T O R S - scan through the CSLabel data structures for <identifier> */
/* CSLabel_iterateServices - look for rating service in a label list
	   (pCSLabel->pCurrentServiceInfo = (ServiceInfo_t *) HTList_nextObject(serviceInfos)) && 
	   SVal_initialized(&pCSLabel->pCurrentServiceInfo->rating_service))
        if (!identifier || !strcasecomp(SVal_value(&pCSLabel->pCurrentServiceInfo->rating_service), identifier)) {
	    ret = (*pIteratorCB)(pCSLabel, pParms, identifier, pVoid);
            count++;
 */
PUBLIC CSError_t CSLabel_iterateServices(CSLabel_t * pCSLabel, CSLabel_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    HTList * serviceInfos;
    CSError_t ret = CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSLabel ||
        !pCSLabel->pCSLLData->serviceInfos)
        return CSError_BAD_PARAM;
    serviceInfos = pCSLabel->pCSLLData->serviceInfos;
    while (ret == CSError_OK && 
	   (pCSLabel->pCurrentServiceInfo = (ServiceInfo_t *) HTList_nextObject(serviceInfos))) {
        if (identifier && 
	    (!SVal_initialized(&pCSLabel->pCurrentServiceInfo->rating_service) || 
	     strcasecomp(SVal_value(&pCSLabel->pCurrentServiceInfo->rating_service), identifier)))
	    continue;
	ret = (*pIteratorCB)(pCSLabel, pParms, identifier, pVoid);
	count++;
    }
    if (!count)
        return CSError_SERVICE_MISSING;
    return ret;
}

/* CSLabel_iterateLabels - look through all labels in current ServiceInfo
 */
PUBLIC CSError_t CSLabel_iterateLabels(CSLabel_t * pCSLabel, CSLabel_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    HTList * labels;
    CSError_t ret= CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSLabel ||
        !pCSLabel->pCurrentServiceInfo ||
        !pCSLabel->pCurrentServiceInfo->labels)
        return CSError_BAD_PARAM;
    labels = pCSLabel->pCurrentServiceInfo->labels;
	while (ret == CSError_OK && (pCSLabel->pCurrentLabel = (Label_t *) HTList_nextObject(labels))) {
            ret = (*pIteratorCB)(pCSLabel, pParms, identifier, pVoid);
            count++;
        }
    if (!count)
        return CSError_LABEL_MISSING;
    return ret;
}

/* CSLabel_iterateSingleLabels - look through all single labels in current label
 */
PUBLIC CSError_t CSLabel_iterateSingleLabels(CSLabel_t * pCSLabel, CSLabel_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    CSError_t ret= CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSLabel ||
        !pCSLabel->pCurrentServiceInfo ||
        !pCSLabel->pCurrentServiceInfo->labels)
        return CSError_BAD_PARAM;
    {
    if (pCSLabel->pCurrentLabel->pSingleLabel) {
        pCSLabel->pCurrentSingleLabel = pCSLabel->pCurrentLabel->pSingleLabel;
            ret = (*pIteratorCB)(pCSLabel, pParms, identifier, pVoid);
            count++;
    }
    else {
        HTList * singleLabels = pCSLabel->pCurrentLabel->singleLabels;
    	while (ret == CSError_OK && (pCSLabel->pCurrentSingleLabel = (SingleLabel_t *) HTList_nextObject(singleLabels))) {
                ret = (*pIteratorCB)(pCSLabel, pParms, identifier, pVoid);
                count++;
            }
        }
    }
    if (!count)
        return CSError_SINGLELABEL_MISSING;
    return ret;
}

/* CSLabel_iterateLabelRatings - look for rating in current single label
 */
PUBLIC CSError_t CSLabel_iterateLabelRatings(CSLabel_t * pCSLabel, CSLabel_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    HTList * labelRatings;
    CSError_t ret = CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSLabel ||
        !pCSLabel->pCurrentServiceInfo ||
        !pCSLabel->pCurrentServiceInfo->labels ||
        !pCSLabel->pCurrentLabel ||
        !pCSLabel->pCurrentSingleLabel ||
        !pCSLabel->pCurrentSingleLabel->labelRatings)
        return CSError_BAD_PARAM;
    labelRatings = pCSLabel->pCurrentSingleLabel->labelRatings;
	while (ret == CSError_OK && (pCSLabel->pCurrentLabelRating = (LabelRating_t *) HTList_nextObject(labelRatings)))
        if (!identifier || !strcasecomp(SVal_value(&pCSLabel->pCurrentLabelRating->identifier), identifier)) {
            ret = (*pIteratorCB)(pCSLabel, pParms, identifier, pVoid);
            count++;
        }
    if (!count)
        return CSError_RATING_MISSING;
    return ret;
}

/* R A N G E   T E S T I N G - check that label values fall within acceptable user ranges */
/* CSLabel_ratingsIncludeFVal - find out if current rating in pCSLabel encompases userValue
 * return: int stating how far it is from fitting.
 */
PUBLIC FVal_t CSLabel_ratingsIncludeFVal(CSLabel_t * pCSLabel, FVal_t * userValue)
{
    Range_t parm = Range_NEW_UNINITIALIZED;
    parm.min = *userValue;
    return CSLabel_ratingsIncludeRange(pCSLabel, &parm);
}

PUBLIC FVal_t CSLabel_ratingsIncludeRange(CSLabel_t * pCSLabel, Range_t * pUserRange)
{
    HTList * labelRanges = pCSLabel->pCurrentLabelRating->ranges;
    FVal_t value = pCSLabel->pCurrentLabelRating->value;
    FVal_t ret;
    Range_t * pLabelRange;
    if (FVal_initialized(&value)) {
        Range_t parm = Range_NEW_UNINITIALIZED;
        parm.min = value;
        return Range_gap(&parm, pUserRange);
    }
    while ((pLabelRange =