ECode CVariableOfStruct::GetStructFieldGetter( /* [in] */ const String& name, /* [out] */ IStructGetter** getter) { if (name.IsNull() || !getter) { return E_INVALID_ARGUMENT; } Int32 index = 0; ECode ec = GetIndexByName(name, &index); if (FAILED(ec)) return ec; if (mStructFieldDesc[index].mType != CarDataType_Struct) { return E_INVALID_ARGUMENT; } AutoPtr<IFieldInfo> fieldInfo; AutoPtr<IStructInfo> structInfo; ec = mStructInfo->GetFieldInfo(name, (IFieldInfo **)&fieldInfo); if (FAILED(ec)) return ec; ec = fieldInfo->GetTypeInfo((IDataTypeInfo **)&structInfo); if (FAILED(ec)) return ec; AutoPtr<IVariableOfStruct> variable; ec = structInfo->CreateVariableBox( mVarBuf + mStructFieldDesc[index].mPos, (IVariableOfStruct **)&variable); if (FAILED(ec)) return ec; return variable->GetGetter(getter); }
String CFileRotator::GetActiveName( /* [in] */ Int64 currentTimeMillis) { String oldestActiveName; Int64 oldestActiveStart = Elastos::Core::Math::INT64_MAX_VALUE; AutoPtr<FileInfo> info = new FileInfo(mPrefix); AutoPtr< ArrayOf<String> > files; ASSERT_SUCCEEDED(mBasePath->List((ArrayOf<String>**)&files)) for (Int32 i = 0; i < files->GetLength(); ++i) { String name = (*files)[i]; if (!info->Parse(name)) continue; // pick the oldest active file which covers current time if (info->IsActive() && info->mStartMillis < currentTimeMillis && info->mStartMillis < oldestActiveStart) { oldestActiveName = name; oldestActiveStart = info->mStartMillis; } } if (!oldestActiveName.IsNull()) { return oldestActiveName; } else { // no active file found above; create one starting now info->mStartMillis = currentTimeMillis; info->mEndMillis = Elastos::Core::Math::INT64_MAX_VALUE; return info->Build(); } }
ECode CActivityOptions::Update( /* [in] */ IActivityOptions* otherOptions) { assert(otherOptions != NULL); String pkgName; otherOptions->GetPackageName(&pkgName); if (!pkgName.IsNull()) { mPackageName = pkgName; } Int32 animationType; otherOptions->GetAnimationType(&animationType); AutoPtr<IRemoteCallback> callback; otherOptions->GetOnAnimationStartListener((IRemoteCallback**)&callback); switch (animationType) { case IActivityOptions::ANIM_CUSTOM: mAnimationType = animationType; otherOptions->GetCustomEnterResId(&mCustomEnterResId); otherOptions->GetCustomExitResId(&mCustomExitResId); mThumbnail = NULL; if (callback != NULL) { // try { callback->SendResult(NULL); // } catch (RemoteException e) { // } } mAnimationStartedListener = callback; break; case IActivityOptions::ANIM_SCALE_UP: mAnimationType = animationType; otherOptions->GetStartX(&mStartX); otherOptions->GetStartX(&mStartY); otherOptions->GetStartWidth(&mStartWidth); otherOptions->GetStartHeight(&mStartHeight); if (callback != NULL) { // try { callback->SendResult(NULL); // } catch (RemoteException e) { // } } mAnimationStartedListener = NULL; break; case IActivityOptions::ANIM_THUMBNAIL_SCALE_UP: case IActivityOptions::ANIM_THUMBNAIL_SCALE_DOWN: mAnimationType = animationType; mThumbnail = NULL; otherOptions->GetThumbnail((IBitmap**)&mThumbnail); otherOptions->GetStartX(&mStartX); otherOptions->GetStartX(&mStartY); if (callback != NULL) { // try { callback->SendResult(NULL); // } catch (RemoteException e) { // } } mAnimationStartedListener = callback; break; } return NOERROR; }
ECode PreferenceActivity::OnHeaderClick( /* [in] */ IPreferenceActivityHeader* header, /* [in] */ Int32 position) { String fragment; header->GetFragment(&fragment); AutoPtr<IIntent> intent; if (!fragment.IsNull()) { if (mSinglePane) { Int32 titleRes; header->GetBreadCrumbTitleRes(&titleRes); Int32 shortTitleRes; header->GetBreadCrumbShortTitleRes(&shortTitleRes); if (titleRes == 0) { header->GetTitleRes(&titleRes); shortTitleRes = 0; } AutoPtr<IBundle> fragmentArguments; header->GetFragmentArguments((IBundle**)&fragmentArguments); StartWithFragment(fragment, fragmentArguments, NULL, 0, titleRes, shortTitleRes); } else { SwitchToHeader(header); } } else if (header->GetIntent((IIntent**)&intent), intent != NULL) { StartActivity(intent); } return NOERROR; }
ECode CTrustAnchor::constructor( /* [in] */ const String& caName, /* [in] */ IPublicKey *caPublicKey, /* [in] */ ArrayOf<Byte> *nameConstraints) { if (caName.IsNull()) { return E_NULL_POINTER_EXCEPTION; } mCaName = caName; if (caPublicKey == NULL) { return E_NULL_POINTER_EXCEPTION; } mCaPublicKey = caPublicKey; // copy nameConstraints if not null if (nameConstraints->GetLength()) { mNameConstraints = ArrayOf<Byte>::Alloc(nameConstraints->GetLength()); mNameConstraints->Copy(0, nameConstraints, 0, mNameConstraints->GetLength()); ProcessNameConstraints(); } else { mNameConstraints = NULL; } mTrustedCert = NULL; // X500Principal checks caName validity if (caName.IsEmpty()) { return E_ILLEGAL_ARGUMENT_EXCEPTION; } AutoPtr<IX500Principal> principal; CX500Principal::New(mCaName, (IX500Principal**)&principal); mCaPrincipal = principal; return NOERROR; }
void SettingsHelper::SetRingtone( /* [in] */ const String& name, /* [in] */ const String& value) { // If it's null, don't change the default if (value.IsNull()) return; AutoPtr<IUri> ringtoneUri; if (SILENT_RINGTONE.Equals(value)) { } else { AutoPtr<IUriHelper> helper; CUriHelper::AcquireSingleton((IUriHelper**)&helper); AutoPtr<IUri> canonicalUri; helper->Parse(value, (IUri**)&canonicalUri); AutoPtr<IContentResolver> resolver; mContext->GetContentResolver((IContentResolver**)&resolver); resolver->Uncanonicalize(canonicalUri, (IUri**)&ringtoneUri); if (ringtoneUri == NULL) { // Unrecognized or invalid Uri, don't restore return; } } const Int32 ringtoneType = ISettingsSystem::RINGTONE.Equals(name) ? IRingtoneManager::TYPE_RINGTONE : IRingtoneManager::TYPE_NOTIFICATION; AutoPtr<IRingtoneManagerHelper> helper; CRingtoneManagerHelper::AcquireSingleton((IRingtoneManagerHelper**)&helper); helper->SetActualDefaultRingtoneUri(mContext, ringtoneType, ringtoneUri); }
//@Override // Binder call ECode CDisplayManagerService::ForgetWifiDisplay( /* [in] */ const String& address) { if (DEBUG) Slogger::D(TAG, "ForgetWifiDisplay address: [%s]", address.string()); if (address.IsNull()) { Slogger::E(TAG, "address must not be NULL"); return E_ILLEGAL_ARGUMENT_EXCEPTION; } if (!CanCallerConfigureWifiDisplay()) { Slogger::E(TAG, "Requires CONFIGURE_WIFI_DISPLAY " "permission to forget a wifi display."); return E_SECURITY_EXCEPTION; } Int64 token = Binder::ClearCallingIdentity(); { AutoLock lock(mSyncRoot); if (mWifiDisplayAdapter != NULL) { mWifiDisplayAdapter->RequestForgetLocked(address); } } Binder::RestoreCallingIdentity(token); return NOERROR; }
String ContentProvider::GetAuthorityWithoutUserId( /* [in] */ const String& auth) { if (auth.IsNull()) return String(NULL); Int32 end = auth.LastIndexOf('@'); return auth.Substring(end + 1); }
ECode ContentProvider::OpenTypedAssetFile( /* [in] */ IUri* uri, /* [in] */ const String& mimeTypeFilter, /* [in] */ IBundle* opts, /* [out] */ IAssetFileDescriptor** fileDescriptor) { VALIDATE_NOT_NULL(fileDescriptor) *fileDescriptor = NULL; if (mimeTypeFilter.Equals("*/*")) { // If they can take anything, the untyped open call is good enough. return OpenAssetFile(uri, String("r"), fileDescriptor); } String baseType; GetType(uri, &baseType); if (!baseType.IsNull()) { AutoPtr<IClipDescriptionHelper> descriptionHelper; CClipDescriptionHelper::AcquireSingleton((IClipDescriptionHelper**)&descriptionHelper); Boolean result = FALSE; descriptionHelper->CompareMimeTypes(baseType, mimeTypeFilter, &result); // Use old untyped open call if this provider has a type for this // URI and it matches the request. if (result) return OpenAssetFile(uri, String("r"), fileDescriptor); } // throw new FileNotFoundException("Can't open " + uri + " as type " + mimeTypeFilter); String str = Object::ToString(uri); Logger::E(TAG, "Can't open %s as type %s", str.string(), mimeTypeFilter.string()); return E_FILE_NOT_FOUND_EXCEPTION; }
Boolean FontFamily::NativeAddFontFromAsset( /* [in] */ Int64 familyPtr, /* [in] */ IAssetManager* assetMgr, /* [in] */ const String& path) { if (assetMgr == NULL || path.IsNull()) { return FALSE; } android::AssetManager* mgr = (android::AssetManager*)((CAssetManager*)assetMgr)->Ni(); if (NULL == mgr) { return FALSE; } android::Asset* asset = mgr->open(path.string(), android::Asset::ACCESS_BUFFER); if (NULL == asset) { return FALSE; } SkStream* stream = new AssetStreamAdaptor(asset, AssetStreamAdaptor::kYes_OwnAsset, AssetStreamAdaptor::kYes_HasMemoryBase); SkTypeface* face = SkTypeface::CreateFromStream(stream); // Note: SkTypeface::CreateFromStream holds its own reference to the stream stream->unref(); if (face == NULL) { Logger::E(String("FontFamily"), String("addFontFromAsset failed to create font %s"), path.string()); return FALSE; } android::FontFamily* fontFamily = reinterpret_cast<android::FontFamily*>(familyPtr); return addSkTypeface(fontFamily, face); }
Boolean URLUtil::IsHttpsUrl( /* [in] */ const String& url) { return (!url.IsNull()) && (url.GetLength() > 7) && url.Substring(0, 8).EqualsIgnoreCase("https://"); }
ECode CEmojiFactory::GetAndroidPuaFromVendorSpecificPua( /* [in] */ const String& vspString, /* [out] */ String* retValue) { VALIDATE_NOT_NULL(retValue); *retValue = NULL; if (vspString.IsNull()) { return E_NULL_POINTER_EXCEPTION; } Int32 minVsp = NativeGetMinimumVendorSpecificPua(mNativeEmojiFactory); Int32 maxVsp = NativeGetMaximumVendorSpecificPua(mNativeEmojiFactory); AutoPtr<ArrayOf<Int32> > codePoints = ArrayOf<Int32>::Alloc(vspString.GetCharCount(0, len));\ Int32 new_len = 0; for (Int32 i=0; i < len; i++,new_len++) Int32 codePoint = (Int32)vspString.GetChar(i); if (minVsp <= codePoint && codePoint <= maxVsp) { Int32 newCodePoint = GetAndroidPuaFromVendorSpecificPua(codePoint); if (newCodePoint > 0) { (*codePoints)[new_len] = newCodePoint; continue; } } (*codePoints)[new_len] = codePoint; }
void CProxyProperties::SetExclusionList( /* [in] */ const String& exclusionList) { mExclusionList = exclusionList.ToLowerCase(); if (exclusionList.IsNull()) { mParsedExclusionList = ArrayOf<String>::Alloc(0); } else { AutoPtr <ArrayOf<String> >splitExclusionList; StringUtils::Split(mExclusionList, String(","), (ArrayOf<String>**)&splitExclusionList); Int32 length; length = splitExclusionList->GetLength(); mParsedExclusionList = ArrayOf<String>::Alloc(length* 2); for (int i = 0; i < length; i++) { String str; str = (*splitExclusionList)[i]; String s = str.Trim(); if (s.StartWith(".")) { s = s.Substring(1); } String temp = String(".") + s; mParsedExclusionList->Set(i*2, s); mParsedExclusionList->Set((i*2)+1, temp); } } }
ECode CProxyProperties::IsExcluded( /* [in] */ const String& url, /* [out] */ Boolean* result) { VALIDATE_NOT_NULL(result); Int32 length; length = mParsedExclusionList->GetLength(); AutoPtr<ICharSequence> chars; CStringWrapper::New(url, (ICharSequence**)&chars); if (TextUtils::IsEmpty((ICharSequence*)&chars) || mParsedExclusionList == NULL ||length == 0) { *result = FALSE; return NOERROR; } AutoPtr<IUri> u; Uri::Parse(url, (IUri**)&u); String urlDomain; u->GetHost(&urlDomain); if (urlDomain.IsNull()) { *result = FALSE; return NOERROR; } Int32 length2; length2 = mParsedExclusionList->GetLength(); for (Int32 i = 0; i< length2; i+=2) { if (urlDomain.Equals((*mParsedExclusionList)[i]) || urlDomain.EndWith((*mParsedExclusionList)[i+1])) { *result = TRUE; return NOERROR; } } *result = FALSE; return NOERROR; }
ECode CClassInfo::GetConstructorInfoByParamNames( /* [in] */ const String& name, /* [out] */ IConstructorInfo** constructorInfo) { if (name.IsNull() || !constructorInfo) { return E_INVALID_ARGUMENT; } if (!(mDesc->dwAttribs & ClassAttrib_hasctor)) { return E_DOES_NOT_EXIST; } ECode ec = AcquireConstructorList(); if (FAILED(ec)) return ec; String objName("CreateObjectWith"); objName += name; ec = mCtorList->AcquireObjByName(objName, (IInterface **)constructorInfo); if (FAILED(ec)) return ec; CConstructorInfo* consInfoObj = (CConstructorInfo*)(*constructorInfo); consInfoObj->mInstClsId.clsid = mClsId.clsid; strcpy(consInfoObj->mInstClsId.pUunm, mClsId.pUunm); return NOERROR; }
ECode IconPackHelper::LoadIconPack( /* [in] */ const String& packageName) { if (packageName.IsNull()) { mLoadedIconPackResource = NULL; mLoadedIconPackName = NULL; mComposedIconInfo->SetIconBacks(NULL); mComposedIconInfo->SetIconMask(0); mComposedIconInfo->SetIconUpon(0); mComposedIconInfo->SetIconScale(0); mComposedIconInfo->SetColorFilter(NULL); } else { mIconBackCount = 0; AutoPtr<IResources> res; FAIL_RETURN(CreateIconResource(mContext, packageName, (IResources**)&res)); FAIL_RETURN(GetIconResMapFromXml(res, packageName, (IMap**)&mIconPackResourceMap)); mLoadedIconPackResource = res; mLoadedIconPackName = packageName; LoadComposedIconComponents(); AutoPtr<IColorMatrix> cm; mFilterBuilder->Build((IColorMatrix**)&cm); if (cm != NULL) { AutoPtr< ArrayOf<Float> > arr; cm->GetArray((ArrayOf<Float>**)&arr); AutoPtr< ArrayOf<Float> > arrClone = arr->Clone(); mComposedIconInfo->SetColorFilter(arrClone); } } return NOERROR; }
ECode SystemProperties::Set( /* [in] */ const String& key, /* [in] */ const String& val) { if (key.IsNull() || key.GetLength() > PROP_NAME_MAX) { // throw new IllegalArgumentException("key.length > " + PROP_NAME_MAX); return E_ILLEGAL_ARGUMENT_EXCEPTION; } if (!val.IsNull() && val.GetLength() > PROP_VALUE_MAX) { // throw new IllegalArgumentException("val.length > " + // PROP_VALUE_MAX); return E_ILLEGAL_ARGUMENT_EXCEPTION; } NativeSet(key, val); return NOERROR; }
ECode CSizeF::ParseSizeF( /* [in] */ const String& string, /* [out] */ ISizeF** size) { VALIDATE_NOT_NULL(size) *size = NULL; if (string.IsNull()) { return E_ILLEGAL_ARGUMENT_EXCEPTION; } //checkNotNull(string, "string must not be null"); Int32 sep_ix = string.IndexOf('*'); if (sep_ix < 0) { sep_ix = string.IndexOf('x'); } if (sep_ix < 0) { // throw invalidSize(string); return E_NUMBER_FORMAT_EXCEPTION; } // try { Float w, h; FAIL_RETURN(StringUtils::Parse(string.Substring(0, sep_ix), &w)) FAIL_RETURN(StringUtils::Parse(string.Substring(sep_ix + 1), &h)) AutoPtr<CSizeF> s; CSizeF::NewByFriend(w, h, (CSizeF**)&s); *size = (ISizeF*)s.Get(); REFCOUNT_ADD(*size) // } catch (NumberFormatException e) { // throw invalidSize(string); // } return NOERROR; }
/** * Add a gesture for the entry * * @param entryName entry name * @param gesture */ ECode CGestureStore::AddGesture( /* [in] */ const String & entryName, /* [in] */ IGesture *gesture) { VALIDATE_NOT_NULL(gesture); if (entryName.IsNull() || entryName.GetLength() == 0) { return NOERROR; } HashMap<String, List<IGesture*> *>::Iterator it=mNamedGestures->Find(entryName); List<IGesture*>* gestures = NULL; if (it != mNamedGestures->End()) gestures = it->mSecond; if (gestures == NULL) { gestures = new List<IGesture*>(); (*mNamedGestures)[entryName] = gestures; } gestures->PushBack(gesture); IInstance * ins = NULL; ECode ec = NOERROR; ec = CInstance::CreateInstance(mSequenceType, mOrientationStyle, gesture, entryName, &ins); ec = mClassifier->AddInstance(ins); if (!(FAILED(ec))) mChanged = TRUE; return ec; }
String CdmaMmiCode::MakeEmptyNull( /* [in] */ const String& s) { if (!s.IsNull() && s.GetLength() == 0) return String(NULL); return s; }
ECode CInstrumentationTestRunner::WatcherResultPrinter::AddFailure( /* [in] */ ITest* test, /* [in] */ ITestFailure* failure) { String message; failure->ExceptionMessage(&message); String trace; failure->Trace(&trace); message.Append("\n"); message.Append(trace); trace = message; String prevTrace; mTestResult->GetString(REPORT_KEY_STACK, &prevTrace); if (!prevTrace.IsNull()) { prevTrace.Append("\n"); prevTrace.Append(trace); trace = prevTrace; } mTestResult->PutString(REPORT_KEY_STACK, trace); mTestResultCode = IInstrumentationTestRunner::REPORT_VALUE_RESULT_FAILURE; // pretty printing String name; ITestCase::Probe(test)->GetName(&name); String result; result.AppendFormat("\nFailure in %s:\n%s", name.string(), trace.string()); mTestResult->PutString(IInstrumentation::REPORT_KEY_STREAMRESULT, result); return NOERROR; }
ECode CKXmlSerializer::StartDocument( /* [in] */ const String& encoding, /* [in] */ Boolean standalone) { FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("<?xml version='1.0' "))); if (!encoding.IsNull()) { mEncoding = encoding; if (encoding.StartWithIgnoreCase("utf")) { /*encoding.ToLowerCase(Locale.US).StartWith("utf")*/ mUnicode = TRUE; } } if (!mEncoding.IsNull()) { FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("encoding='"))); FAIL_RETURN(IWriter::Probe(mWriter)->Write(mEncoding)); FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("' "))); } FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("standalone='"))); FAIL_RETURN(IWriter::Probe(mWriter)->Write( standalone ? String("yes") : String("no"))); FAIL_RETURN(IWriter::Probe(mWriter)->Write(String("' "))); return IWriter::Probe(mWriter)->Write(String("?>")); }
ECode HttpURLConnection::GetResponseCode( /* [out] */ Int32* responseCode) { VALIDATE_NOT_NULL(responseCode) // Call getInputStream() first since getHeaderField() doesn't return // exceptions AutoPtr<IInputStream> is; FAIL_RETURN(GetInputStream((IInputStream**)&is)); String response; GetHeaderField(0, &response); if (response.IsNull()) { *responseCode = -1; return NOERROR; } response = response.Trim(); Int32 mark = response.IndexOf(" ") + 1; if (mark == 0) { *responseCode = -1; return NOERROR; } Int32 last = mark + 3; if (last > response.GetLength()) { last = response.GetLength(); } mResponseCode = StringUtils::ParseInt32(response.Substring(mark, last)); if ((last + 1) <= response.GetLength()) { mResponseMessage = response.Substring(last + 1); } *responseCode = mResponseCode; return NOERROR; }
/** * Trim leading zeros from IPv4 address strings * Our base libraries will interpret that as octel.. * Must leave non v4 addresses and host names alone. * For example, 192.168.000.010 -> 192.168.0.10 * TODO - fix base libraries and remove this function * @param addr a string representing an ip addr * @return a string propertly trimmed */ String NetworkUtils::TrimV4AddrZeros( /* [in] */ const String& addr) { if (addr.IsNull()) { return String(NULL); } AutoPtr<ArrayOf<String> > octets; StringUtils::Split(addr, String("\\."), (ArrayOf<String>**)&octets); if (octets->GetLength() != 4) { return addr; } StringBuffer buff; for (Int32 i = 0; i < 4; i++) { // try { if ((*octets)[i].GetLength() > 3) { return addr; } buff += (*octets)[i]; // } catch (NumberFormatException e) { // return addr; // } if (i < 3) buff += String("."); } return buff.ToString(); }
ECode StringEntity::Init( /* [in] */ const String& s, /* [in] */ const String& _charset) { String charset = _charset; if (s.IsNull()) { Logger::E("StringEntity", "Source string may not be null"); return E_ILLEGAL_ARGUMENT_EXCEPTION; } if (charset.IsNull()) { charset = IHTTP::DEFAULT_CONTENT_CHARSET; } mContent = s.GetBytes();// mContent = s.GetBytes(charset); SetContentType(IHTTP::PLAIN_TEXT_TYPE + IHTTP::CHARSET_PARAM + charset); return NOERROR; }
/*static*/ ECode CRingtoneManager::GetActualDefaultRingtoneUri( /* [in] */ IContext* context, /* [in] */ Int32 type, /* [out] */ IUri** result) { VALIDATE_NOT_NULL(result); String setting = GetSettingForType(type); if (setting == NULL) { *result = NULL; return NOERROR; } AutoPtr<IContentResolver> contentResolver; context->GetContentResolver((IContentResolver**)&contentResolver); String uriString; FAIL_RETURN(Settings::System::GetString(contentResolver, setting, &uriString)) AutoPtr<IUriHelper> uriHelper; CUriHelper::AcquireSingleton((IUriHelper**)&uriHelper); AutoPtr<IUri> uri; uriHelper->Parse(uriString, (IUri**)&uri); *result = !uriString.IsNull() ? uri : NULL; REFCOUNT_ADD(*result); return NOERROR; }
ECode CExifInterface::GetAttributeDouble( /* [in] */ const String& tag, /* [in] */ Double defaultValue, /* [out] */ Double* result) { VALIDATE_NOT_NULL(result); *result = defaultValue; HashMap<String, String>::Iterator it = mAttributes.Find(tag); if (it != mAttributes.End()) { String value = it->mSecond; if (value.IsNull()) { return NOERROR; } Int32 index = value.IndexOf("/"); if (index == -1) { return NOERROR; } Double denom = StringUtils::ParseDouble(value.Substring(index + 1)); if (denom == 0) { return NOERROR; } Double num = StringUtils::ParseDouble(value.Substring(0, index)); *result = num / denom; } return NOERROR; }
ECode CJDBCConnection::SetTransactionIsolation( /* [in] */ Int32 level) { Boolean value; ECode ec = NOERROR; mDb->Is3(&value); if (value) { String flag; if (level == IConnection::TRANSACTION_READ_UNCOMMITTED && mTrmode != IConnection::TRANSACTION_READ_UNCOMMITTED) { flag = "on"; } else if (level == IConnection::TRANSACTION_SERIALIZABLE && mTrmode != IConnection::TRANSACTION_SERIALIZABLE) { flag = "off"; } if (!flag.IsNull()) { ec = mDb->Exec(String(""), NULL); //db.exec("PRAGMA read_uncommitted = " + flag + ";", null); mTrmode = level; } else { return E_SQL_EXCEPTION; } } if (level != mTrmode) { return E_SQL_EXCEPTION; } return ec; }
ECode CFastXmlSerializer::EscapeAndAppendString( /* [in] */ const String& string) { AutoPtr<ArrayOf<Char32> > charArray = string.GetChars(); Int32 N = charArray->GetLength(); Char32 NE = (Char32)ESCAPE_TABLE->GetLength(); AutoPtr<ArrayOf<String> > escapes = ESCAPE_TABLE; Int32 lastPos = 0; Int32 pos; Char32 c; String escape; for (pos=0; pos < N; pos++) { c = (*charArray)[pos]; if (c >= NE) continue; escape = (*escapes)[c]; if (escape.IsNull()) continue; if (lastPos < pos) FAIL_RETURN(Append(string, lastPos, pos-lastPos)); lastPos = pos + 1; FAIL_RETURN(Append(escape)); } if (lastPos < pos) FAIL_RETURN(Append(string, lastPos, pos-lastPos)); return NOERROR; }
ECode CVariableOfStruct::GetFieldValueByName( /* [in] */ const String& name, /* [in] */ void* param, /* [in] */ CarDataType type) { if(name.IsNull() || !param) { return E_INVALID_ARGUMENT; } if (!mVarBuf) { return E_INVALID_OPERATION; } Int32 index = 0; ECode ec = GetIndexByName(name, &index); if (FAILED(ec)) return ec; if (type != mStructFieldDesc[index].mType) { return E_INVALID_ARGUMENT; } memcpy(param, mVarBuf + mStructFieldDesc[index].mPos, mStructFieldDesc[index].mSize); return NOERROR; }