C++ VString::Clear方法代码示例

bool JS4D::StringToVString( StringRef inJSString, VString& outString)
{
	bool ok;
	if (inJSString != NULL)
	{
		size_t length = JSStringGetLength( inJSString);
		UniChar *p = outString.GetCPointerForWrite( length);
		if (p != NULL)
		{
			::memcpy( p, JSStringGetCharactersPtr( inJSString), length * sizeof( UniChar));
			ok = outString.Validate( length);
		}
		else
		{
			outString.Clear();
			ok = false;
		}
	}
	else
	{
		ok = false;
		outString.Clear();
	}
	return ok;
}

void AXMLElement::GetData( VString &pCData)
{
	AXMLGenericElement	*elem;
	VString			vCData;

	vCData.Clear();
	pCData.Clear();
	elem = Get_FirstChild();
	while (elem) {
		elem->GetData(vCData);
		pCData.AppendString(vCData);
//		pCData.AppendChar((uBYTE)0x0D);
		elem = elem->GetNext();
	}
}

Boolean VMacResFile::GetString(VString& outString, sLONG inID) const
{
	outString.Clear();

	if (!testAssert(fRefNum != -1))
		return false;
	
	if (!testAssert(inID >= -32768 && inID <= 32767))
		return false;

	sWORD	curres = ::CurResFile();
	if (curres != fRefNum)
		::UseResFile(fRefNum);

	Handle data = fUseResourceChain ? ::GetResource('STR ', (short) inID) : ::Get1Resource('STR ', (short) inID);

	if (curres != fRefNum)
		::UseResFile(curres);
		
	Boolean isOK = false;
	if (testAssert(data != NULL))
	{
		if (testAssert(*data != NULL))
		{
			::HLock(data);
			outString.MAC_FromMacPString((StringPtr) *data);
			::HUnlock(data);
			isOK = true;
		}
	}
	return isOK;
}

void VJSPropertyIterator::GetPropertyName( VString& outName) const
{
	if (testAssert( fIndex < fCount))
		JS4D::StringToVString( JSPropertyNameArrayGetNameAtIndex( fNameArray, fIndex), outName);
	else
		outName.Clear();
}

void XMacFontMgr::GetStdFont( StdFont inFont, VString& outName, VFontFace& outFace, GReal& outSize)
{
	// on risque de perdre des infos, il faudrait retourner une VFont
	
	CTFontUIFontType fontType = StdFontToThemeFontID( inFont);
	CTFontRef fontRef = ::CTFontCreateUIFontForLanguage( fontType, 0 /*size*/, NULL /*language*/ );

	if (testAssert( fontRef != NULL))
	{
		outSize = ::CTFontGetSize( fontRef);

		CFStringRef cfName = ::CTFontCopyFamilyName( fontRef);
		if (cfName != NULL)
		{
			outName.MAC_FromCFString( cfName);
			::CFRelease( cfName);
		}
		else
		{
			outName.Clear();
		}
		
		CTFontSymbolicTraits traits = ::CTFontGetSymbolicTraits( fontRef);
		outFace = 0;
		
		if (traits & kCTFontItalicTrait)
			outFace |= KFS_ITALIC;
		
		if (traits & kCTFontBoldTrait)
			outFace |= KFS_BOLD;
		
		if (traits & kCTFontExpandedTrait)
			outFace |= KFS_EXTENDED;
		
		if (traits & kCTFontCondensedTrait)
			outFace |= KFS_CONDENSED;

		CFRelease( fontRef); 
	}
	else
	{
		outName.Clear();
		outSize = 0;
		outFace = 0;
	}
}

Boolean IPropertyCollector::GetName(VString& outName) const
{
	Boolean succeed = GetString(CVSTR("name"), outName);
	
	if (!succeed)
		outName.Clear();
	
	return succeed;
}

bool XWinIntlMgr::GetLocaleInfo( LCTYPE inType, VString& outInfo) const
{
	UniChar info[256];
	int r = ::GetLocaleInfoW( fDialect, inType, info, sizeof( info) / sizeof( UniChar));
	if (testAssert( r != 0))
		outInfo = info;
	else
		outInfo.Clear();
	return r != 0;
}

bool VJSObject::GetPropertyAsString(const VString& inPropertyName, JS4D::ExceptionRef *outException, VString& outResult) const
{
	bool ok = false;
	VJSValue result(GetProperty(inPropertyName, outException));
	outResult.Clear();
	if (!result.IsNull() && !result.IsUndefined())
	{
		ok = result.GetString(outResult, outException);
	}
	return ok;
}

void AXMLElement::GetAttribute(const VString &pAttributename,VString &pValue) {
	AXMLAttribute	*attribute = NULL;
	attribute = fFirstAttribute;
	while (attribute)
	{
		if (attribute->GetName() == pAttributename) break;
		attribute = attribute->GetNext();
	}
	if (attribute) pValue.FromString(attribute->GetValue());
	else pValue.Clear();
}

void VProcess::GetBuildNumber( VString& outName) const
{
	// product version string should be formatted as follows: 1.0 build 2.108412
	VIndex pos = fProductVersion.Find( "build ");
	if (pos > 0)
	{
		fProductVersion.GetSubString( pos + 6, fProductVersion.GetLength() - pos - 5, outName); 
		outName.RemoveWhiteSpaces();
	}
	else
	{
		outName.Clear();
	}
}

	virtual	VError HandleRequest( IHTTPResponse* inResponse)
			{
				if (inResponse == NULL)
					return VE_INVALID_PARAMETER;

				VError err = VE_OK;
				bool done = false;

				// First, extract the relative path from the url
				VString path = inResponse->GetRequest().GetURLPath();
				VRegexMatcher *matcher = VRegexMatcher::Create( fPattern, &err);
				if ((matcher != NULL) && (err == VE_OK))
				{
					bool match = matcher->Find( path, 1, false, &err);
					if (match && (err == VE_OK))
					{
						// Remove the pattern from the path
						path.Remove( matcher->GetGroupStart(0), matcher->GetGroupLength(0));

						// Check whether a namespace is specified
						VString lNamespaceKey( L"namespace=");
						VString lNamespace = inResponse->GetRequest().GetURLQuery();
						if (lNamespace.BeginsWith( lNamespaceKey))
							lNamespace.Remove( 1, lNamespaceKey.GetLength());
						else
							lNamespace.Clear();

						// Now, we have a relative  module path
						VString proxy;
						err = fService->GetProxy( proxy, path, lNamespace, &inResponse->GetRequest(), inResponse);
						if (err == VE_OK)
						{
							VString contentType( L"application/javascript");
							err = SetHTTPResponseString( inResponse, proxy, &contentType);
							done = true;
						}
					}
				}
				ReleaseRefCountable( &matcher);

				if (!done)
					err = inResponse->ReplyWithStatusCode( HTTP_NOT_FOUND);

				return err;
			}

bool VEnvironmentVariables::GetEnvironmentVariableValue(const VString &inEnvName, VString &outEnvValue, bool inAndRemoveIt)
{
	bool	gotIt = false;
	
	outEnvValue.Clear();
	if(!inEnvName.IsEmpty() && !fEnvVars.empty())
	{
		EnvVarNamesAndValuesMap::iterator	envVarIt = fEnvVars.find(inEnvName);
		if(envVarIt != fEnvVars.end())
		{
			outEnvValue = envVarIt->second;
			gotIt = true;
			if(inAndRemoveIt)
				fEnvVars.erase(envVarIt);
		}
	}
	
	return gotIt;
}

VError VMacResFile::GetResourceName(const VString& inType, sLONG inID, VString& outName) const
{
	outName.Clear();
	Handle data = NULL;
	VError error = _GetResource(inType, inID, &data);
	if (error == VE_OK)
	{
		ResType type;
		sWORD	id;
		Str255 spName;
		::GetResInfo(data, &id, &type, spName);
		OSErr macError = ::ResError();
		if (testAssert(macError == noErr))
		{
			outName.MAC_FromMacPString(spName);
		} else
			error = VErrorBase::NativeErrorToVError((VNativeError)macError);
	}
	return error;
}

void XWinIntlMgr::FormatTime( const VTime& inTime, VString& outTime, EOSFormats inFormat, bool inUseGMTTimeZoneForDisplay)
{
	// 1:system short time; 2:system medium time; 3:system long time

	DWORD timeFormat=0;
	switch(inFormat)
	{
		case eOS_SHORT_FORMAT:// No signs
		case eOS_MEDIUM_FORMAT:// No signs
			timeFormat=TIME_NOTIMEMARKER;
			break;
		case eOS_LONG_FORMAT://all
			break;
		default:
			break;
	};

	// Prepare SYSTEMTIME for windows.
	sWORD YY=0,MM=0,DD=0,hh=0,mm=0,ss=0,ms=0;
	SYSTEMTIME osTime={0};
	if (inUseGMTTimeZoneForDisplay)
		inTime.GetUTCTime (YY,MM,DD,hh,mm,ss,ms);
	else
		inTime.GetLocalTime (YY,MM,DD,hh,mm,ss,ms);
	osTime.wYear=YY;
	osTime.wMonth=MM;
	osTime.wDay=DD;
	osTime.wHour=hh;
	osTime.wMinute=mm;
	osTime.wSecond=ss;
	osTime.wMilliseconds=ms;

	// Let the OS do the stuff.
	UniChar acBuffer[256];
	if (::GetTimeFormatW( fDialect,timeFormat,&osTime,NULL,acBuffer,sizeof(acBuffer)))
		outTime=acBuffer;
	else
		outTime.Clear();
}

void VFolder::GetPath( VString &outPath, FilePathStyle inPathStyle) const
{
	switch (inPathStyle)
	{
		case FPS_SYSTEM :
			fPath.GetPath( outPath );
			break;

		case FPS_POSIX :
			{
				VError err = fFolder.GetPosixPath( outPath);
				if (err != VE_OK)
					fPath.GetPosixPath( outPath);	// boff
				break;
			}
			break;

		default:
			xbox_assert( false);
			outPath.Clear();
			break;
	}
}