sbineturl.cpp

Open VXI. This is a open source.

  tempBuf[0] = 0;
  switch( VXIValueGetType(value)) {
  case VALUE_INTEGER: 
    {
      VXIint32 valInt = VXIIntegerValue( (VXIInteger *)value );
      sprintf (tempBuf, "%i", valInt);
    } break;
  case VALUE_FLOAT: 
    {
      VXIflt32 valFloat = VXIFloatValue( (VXIFloat *)value );
      sprintf (tempBuf, "%f", valFloat);
    } break;
  case VALUE_STRING: 
    {
      rVal = VXIStringCStr( (VXIString *)value );
    } break;
  case VALUE_PTR: 
    {
      void *valPtr = VXIPtrValue( (VXIPtr *)value );
      sprintf (tempBuf, "%p", valPtr);
    } break;
  case VALUE_MAP: 
  case VALUE_VECTOR: 
  case VALUE_CONTENT:
  default:
    {
      // These types are supposed to be handled before entering this func
    } break;
  } // end switch()

  // Convert back to wide characters if necessary
  if (tempBuf[0]) {
    int i = 0;
    do {
      outBuf[i] = tempBuf[i];
      i++;
    } while (tempBuf[i]);
    outBuf[i] = L'\0';
  }

  return(rVal);
}



int
SBinetURL::NeedMultipart(const VXIMap* queryArgs)
{
  // Create a list to hold the form arguments, then parse the
  // data and add the key-value pairs to the association list
  const VXIchar  *key = NULL;
  const VXIValue *value = NULL;
  if(!queryArgs) return(0);
  VXIMapIterator *mapIterator = VXIMapGetFirstProperty( queryArgs, &key, &value );
  do{
      if (( key != NULL ) && ( value != NULL ))	{
	if(VXIValueGetType(value) == VALUE_CONTENT) return(1);
      }
  } while ( VXIMapGetNextProperty( mapIterator, &key, &value ) == VXIvalue_RESULT_SUCCESS );
  VXIMapIteratorDestroy(&mapIterator);
  return(0);
}


void SBinetURL::AppendKeyValuePairToURL( const VXIchar *key,
                                         const VXIchar *value,
                                         VXIbool *isFirstArg )
{    
  if(key && value){
    if( *isFirstArg ) {
      m_strAbsoluteUrl += L"?";
      *isFirstArg = false;
    }
    else
      m_strAbsoluteUrl += L"&";

    VXIchar *escapedKey = EscapeStringW(key);
    VXIchar *escapedValue = EscapeStringW(value);

	m_strAbsoluteUrl += escapedKey;
	m_strAbsoluteUrl += L"=";
	m_strAbsoluteUrl += escapedValue;

    free(escapedKey);
    free(escapedValue);
  }
}


void SBinetURL::AppendQueryArgsVector( const VXIVector *vector,
                                       VXIchar *fieldName, 
                                       VXIbool *isFirstArg )
{
  const VXIValue *value = NULL;

  VXIunsigned vectorLen = VXIVectorLength(vector);
  VXIunsigned i;

  for(i = 0 ; i < vectorLen ; i++) {
    value = VXIVectorGetElement(vector, i);
    if ( value != NULL ){
      VXIunsigned prevLen = ::wcslen(fieldName);
      AppendArrayIndexToName(fieldName, i);

	  if(VXIValueGetType(value) == VALUE_MAP) {  // nested object
        // Append the object name to the field name prefix
        AppendQueryArgsMap((const VXIMap *)value, fieldName, isFirstArg); // Parse map
      }
	  else if(VXIValueGetType(value) == VALUE_VECTOR) {  // nested vector
        // Append the vector name to the field name prefix
        AppendQueryArgsVector((const VXIVector *)value, fieldName, isFirstArg); // Recursive
      }
      else {
        VXIchar tempBuf[2048];

        const VXIchar* valStr = ValueToString(value, tempBuf, 2048);
        AppendKeyValuePairToURL(fieldName, valStr, isFirstArg);
      }

      fieldName[prevLen] = L'\0'; // Remove the array index
    }
  }
}


void SBinetURL::AppendQueryArgsMap( const VXIMap *map,
                                    VXIchar *fieldName, 
                                    VXIbool *isFirstArg )
{
  const VXIchar  *key = NULL;
  const VXIValue *value = NULL;

  VXIMapIterator *mapIterator = VXIMapGetFirstProperty( map, &key, &value );
  do{
    if (( key != NULL ) && ( value != NULL )){
	  if(VXIValueGetType(value) == VALUE_MAP) {  // nested object
        // Append the object name to the field name prefix
        if( fieldName[0] != L'\0' ) 
          wcscat(fieldName, L".");
        wcscat(fieldName, key);
        AppendQueryArgsMap((const VXIMap *)value, fieldName, isFirstArg); // Recursive
      }
	  else if(VXIValueGetType(value) == VALUE_VECTOR) {  // nested vector
        // Append the object name to the field name prefix
        if( fieldName[0] != L'\0' ) 
          wcscat(fieldName, L".");
        wcscat(fieldName, key);
        AppendQueryArgsVector((const VXIVector *)value, fieldName, isFirstArg); // Parse vector
      }
      else {
        VXIchar tempBuf[2048];

        // Append the real field name to the field name prefix
        VXIint fieldNameLen = ::wcslen(fieldName);
        if( fieldName[0] != L'\0' ) 
          wcscat(fieldName, L".");
        wcscat(fieldName, key);

        const VXIchar* valStr = ValueToString(value, tempBuf, 2048);
        AppendKeyValuePairToURL(fieldName, valStr, isFirstArg);

        // Remove the just appended file name, leave only the prefix
        fieldName[fieldNameLen] = L'\0';
      }
    }
  } while ( VXIMapGetNextProperty( mapIterator, &key, &value ) == VXIvalue_RESULT_SUCCESS );
  
  // Cut the last object name from the field name prefix
  VXIchar *fieldNamePtr = wcsrchr(fieldName, L'.');
  if( fieldNamePtr != NULL )
    *fieldNamePtr = L'\0';
  else
    fieldName[0] = L'\0';

  VXIMapIteratorDestroy(&mapIterator);
}


void
SBinetURL::AppendQueryArgs(const VXIMap* queryArgs)
{
  // Create a list to hold the form arguments, then parse the
  // data and add the key-value pairs to the association list
  VXIchar tempBuf[2048];
  const VXIchar  *key = NULL;
  const VXIValue *value = NULL;
  VXIbool isFirstArg = true;

  if(!queryArgs) return;

  // Use STL as we are already. I hope find() is portable.
  if((int)m_strAbsoluteUrl.find(L'?') == 0 ) isFirstArg = false;

  VXIMapIterator *mapIterator = VXIMapGetFirstProperty( queryArgs, &key, &value );
  do{
    if (( key != NULL ) && ( value != NULL )) {
      VXIchar objPrefix[512] = L"";

	  if(VXIValueGetType(value) == VALUE_MAP) {  // nested object
        VXIchar fieldName[1024];
        wcscpy(fieldName, key);
        AppendQueryArgsMap((const VXIMap *)value, fieldName, &isFirstArg); // Parse map
      }
      else if(VXIValueGetType(value) == VALUE_VECTOR) { // nested vector
        VXIchar fieldName[1024];
        wcscpy(fieldName, key);
        AppendQueryArgsVector((const VXIVector *)value, fieldName, &isFirstArg); // Parse vector
      }
      else {
        const VXIchar* valStr = ValueToString(value, tempBuf, 2048);
        AppendKeyValuePairToURL(key, valStr, &isFirstArg);
      }
    }
  } while ( VXIMapGetNextProperty( mapIterator, &key, &value ) == VXIvalue_RESULT_SUCCESS );

  VXIMapIteratorDestroy(&mapIterator);
}


char *SBinetURL::EscapeString( const VXIchar *value )
{
  char tempVal[2048];

  int len = ::wcslen(value);
  if(len > 2047) len = 2047;  // should realloc but...
  ::wcstombs( tempVal, value, len );
  tempVal[len] = '\0';
  
  return HTEscape(tempVal, URL_XALPHAS);
} 

VXIchar *SBinetURL::EscapeStringW( const VXIchar *value )
{
  char *escaped = EscapeString(value);
  if(escaped == NULL) return NULL;

  int len = ::strlen(escaped) + 1;
  VXIchar *retStr = (VXIchar *)malloc(len * sizeof(VXIchar));
  if(retStr == NULL) return NULL;

  ::mbstowcs(retStr, escaped, len);
  return retStr;
} 


void SBinetURL::AddObjectToHTAssocList( HTAssocList *arglist,
                                        const VXIchar *key,
                                        const VXIchar *value )
{    
  if((key == NULL) || (value == NULL)) return;

  char *escapedKey = EscapeString(key);
  char *escapedValue = EscapeString(value);

  HTAssocList_addObject( arglist, escapedKey, escapedValue );

  free(escapedKey);
  free(escapedValue);
}


void SBinetURL::QueryArgsVectorToHtList( HTAssocList *arglist, 
                                         const VXIVector *vector, 
                                         VXIchar *fieldName )
{
  const VXIValue *value = NULL;

  VXIunsigned vectorLen = VXIVectorLength(vector);
  VXIunsigned i;

  for(i = 0 ; i < vectorLen ; i++) {
    value = VXIVectorGetElement(vector, i);
    if ( value != NULL ){
      VXIunsigned prevLen = ::wcslen(fieldName);
      AppendArrayIndexToName(fieldName, i);

	  if(VXIValueGetType(value) == VALUE_MAP) {  // nested object
        // Append the object name to the field name prefix
        QueryArgsMapToHtList(arglist, (const VXIMap *)value, fieldName); // Parse map
      }
	  else if(VXIValueGetType(value) == VALUE_VECTOR) {  // nested vector
        // Append the vector name to the field name prefix
        QueryArgsVectorToHtList(arglist, (const VXIVector *)value, fieldName); // Recursive
      }
      else {
        VXIchar tempBuf[2048];

        const VXIchar* valStr = ValueToString(value, tempBuf, 2048);
        AddObjectToHTAssocList(arglist, fieldName, valStr);
      }

      fieldName[prevLen] = L'\0'; // Remove the array index
    }
  }
}


void SBinetURL::QueryArgsMapToHtList( HTAssocList *arglist, 
                                      const VXIMap *map, 
                                      VXIchar *fieldName )
{
  const VXIchar  *key = NULL;
  const VXIValue *value = NULL;

  VXIMapIterator *mapIterator = VXIMapGetFirstProperty( map, &key, &value );
  do{
    if (( key != NULL ) && ( value != NULL )){
	  if(VXIValueGetType(value) == VALUE_MAP) {  // nested object
        // Append the object name to the field name prefix
        if( fieldName[0] != L'\0' ) 
          wcscat(fieldName, L".");
        wcscat(fieldName, key);
        QueryArgsMapToHtList(arglist, (const VXIMap *)value, fieldName); // Recursive
      }
	  else if(VXIValueGetType(value) == VALUE_VECTOR) {  // nested vector
        // Append the object name to the field name prefix
        if( fieldName[0] != L'\0' ) 
          wcscat(fieldName, L".");
        wcscat(fieldName, key);
        QueryArgsVectorToHtList(arglist, (const VXIVector *)value, fieldName); // Parse vector
      }
      else {
        VXIchar tempBuf[2048];

        // Append the real field name to the field name prefix
        VXIint fieldNameLen = ::wcslen(fieldName);
        if( fieldName[0] != L'\0' ) 
          wcscat(fieldName, L".");
        wcscat(fieldName, key);

        const VXIchar* valStr = ValueToString(value, tempBuf, 2048);
        AddObjectToHTAssocList(arglist, fieldName, valStr);

        // Remove the just appended file name, leave only the prefix
        fieldName[fieldNameLen] = L'\0';
      }
    }
  } while ( VXIMapGetNextProperty( mapIterator, &key, &value ) == VXIvalue_RESULT_SUCCESS );
  
  // Cut the last object name from the field name prefix
  VXIchar *fieldNamePtr = wcsrchr(fieldName, L'.');
  if( fieldNamePtr != NULL )
    *fieldNamePtr = L'\0';
  else
    fieldName[0] = L'\0';

  VXIMapIteratorDestroy(&mapIterator);
}


HTAssocList*
SBinetURL::QueryArgsToHtList(const VXIMap* queryArgs){
  // Create a list to hold the form arguments, then parse the
  // data and add the key-value pairs to the association list
  const VXIchar  *key = NULL;
  const VXIValue *value = NULL;
  VXIchar tempBuf[2048];

  if(!queryArgs) return(NULL);
  HTAssocList* arglist = NULL;

  VXIMapIterator *mapIterator = VXIMapGetFirstProperty( queryArgs, &key, &value );
  do{
    if (( key != NULL ) && ( value != NULL )){
      if( arglist == NULL ) 
        arglist = HTAssocList_new();

	  if(VXIValueGetType(value) == VALUE_MAP) {  // nested object
        VXIchar fieldName[1024];
        wcscpy(fieldName, key);