自学教程：C++ GetParentObject函数代码示例

FVector FGeomEdge::GetWidgetLocation(){	FVector dir = (GetParentObject()->VertexPool[ VertexIndices[1] ] - GetParentObject()->VertexPool[ VertexIndices[0] ]);	const float dist = dir.Size() / 2;	dir.Normalize();	const FVector loc = GetParentObject()->VertexPool[ VertexIndices[0] ] + (dir * dist);	return GetParentObject()->GetActualBrush()->ActorToWorld().TransformPosition( loc );}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CObjectSapper::DetachObjectFromObject( void ){	if ( GetParentObject() )	{		GetParentObject()->OnRemoveSapper();	}	BaseClass::DetachObjectFromObject();}

FVector FGeomEdge::GetMidPoint() const{	const FGeomVertex* wk0 = &(GetParentObject()->VertexPool[ VertexIndices[0] ]);	const FGeomVertex* wk1 = &(GetParentObject()->VertexPool[ VertexIndices[1] ]);	const FVector v0( wk0->X, wk0->Y, wk0->Z );	const FVector v1( wk1->X, wk1->Y, wk1->Z );	return (v0 + v1) / 2;}

FileList*DataTransfer::GetFiles(ErrorResult& aRv){    if (mEventType != NS_DRAGDROP_DROP && mEventType != NS_DRAGDROP_DRAGDROP &&            mEventType != NS_PASTE) {        return nullptr;    }    if (!mFiles) {        mFiles = new FileList(static_cast<nsIDOMDataTransfer*>(this));        uint32_t count = mItems.Length();        for (uint32_t i = 0; i < count; i++) {            nsCOMPtr<nsIVariant> variant;            aRv = MozGetDataAt(NS_ConvertUTF8toUTF16(kFileMime), i, getter_AddRefs(variant));            if (aRv.Failed()) {                return nullptr;            }            if (!variant)                continue;            nsCOMPtr<nsISupports> supports;            nsresult rv = variant->GetAsISupports(getter_AddRefs(supports));            if (NS_FAILED(rv))                continue;            nsCOMPtr<nsIFile> file = do_QueryInterface(supports);            nsRefPtr<File> domFile;            if (file) {                domFile = File::CreateFromFile(GetParentObject(), file);            } else {                nsCOMPtr<FileImpl> fileImpl = do_QueryInterface(supports);                if (!fileImpl) {                    continue;                }                domFile = new File(GetParentObject(), static_cast<FileImpl*>(fileImpl.get()));            }            if (!mFiles->Append(domFile)) {                aRv.Throw(NS_ERROR_FAILURE);                return nullptr;            }        }    }    return mFiles;}

//-----------------------------------------------------------------------------// Purpose: Heal the object I'm attached to//-----------------------------------------------------------------------------void CObjectSelfHeal::SelfHealThink( void ){	if ( !GetTeam() )		return;	CBaseObject *pObject = GetParentObject();	if ( !pObject )	{		Killed();		return;	}	SetNextThink( gpGlobals->curtime + obj_selfheal_rate.GetFloat(), SELFHEAL_THINK_CONTEXT );	// Don't heal if we've been EMPed	if ( HasPowerup( POWERUP_EMP ) )		return;	// Don't bring objects back from the dead	if ( !pObject->IsAlive() || pObject->IsDying() )		return;	// Repair our parent if it's hurt	pObject->Repair( obj_selfheal_amount.GetFloat() );}

void C4ObjectMenu::LocalInit(C4Object *pObject, bool fUserMenu){	Object=pObject;	UserMenu=fUserMenu;	ParentObject=GetParentObject();	if (pObject) eCallbackType = CB_Object; else eCallbackType = CB_Scenario;}

already_AddRefed<Promise>MediaKeys::CreateSession(const nsAString& initDataType,                         const Uint8Array& aInitData,                         SessionType aSessionType,                         ErrorResult& aRv){  aInitData.ComputeLengthAndData();  nsRefPtr<Promise> promise(MakePromise(aRv));  if (aRv.Failed()) {    return nullptr;  }  nsRefPtr<MediaKeySession> session = new MediaKeySession(GetParentObject(),                                                          this,                                                          mKeySystem,                                                          aSessionType, aRv);  if (aRv.Failed()) {    return nullptr;  }  auto pid = StorePromise(promise);  // Hang onto session until the CDM has finished setting it up.  mPendingSessions.Put(pid, session);  mProxy->CreateSession(aSessionType,                        pid,                        initDataType,                        aInitData);  return promise.forget();}

nsresultIDBRequest::NotifyHelperCompleted(HelperBase* aHelper){  NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");  NS_ASSERTION(!mHaveResultOrErrorCode, "Already called!");  NS_ASSERTION(JSVAL_IS_VOID(mResultVal), "Should be undefined!");  // See if our window is still valid. If not then we're going to pretend that  // we never completed.  if (NS_FAILED(CheckInnerWindowCorrectness())) {    return NS_OK;  }  mHaveResultOrErrorCode = true;  nsresult rv = aHelper->GetResultCode();  // If the request failed then set the error code and return.  if (NS_FAILED(rv)) {    SetError(rv);    return NS_OK;  }  // Otherwise we need to get the result from the helper.  JSContext* cx = GetJSContext();  if (!cx) {    NS_WARNING("Failed to get safe JSContext!");    rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;    SetError(rv);    return rv;  }  JSObject* global = GetParentObject();  NS_ASSERTION(global, "This should never be null!");  JSAutoRequest ar(cx);  JSAutoEnterCompartment ac;  if (ac.enter(cx, global)) {    AssertIsRooted();    rv = aHelper->GetSuccessResult(cx, &mResultVal);    if (NS_FAILED(rv)) {      NS_WARNING("GetSuccessResult failed!");    }  }  else {    NS_WARNING("Failed to enter correct compartment!");    rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;  }  if (NS_SUCCEEDED(rv)) {    mError = nullptr;  }  else {    SetError(rv);    mResultVal = JSVAL_VOID;  }  return rv;}

already_AddRefed<Promise> MediaDevices::GetDisplayMedia(    const DisplayMediaStreamConstraints& aConstraints, CallerType aCallerType,    ErrorResult& aRv) {  RefPtr<Promise> p = Promise::Create(GetParentObject(), aRv);  if (NS_WARN_IF(aRv.Failed())) {    return nullptr;  }  RefPtr<MediaDevices> self(this);  MediaManager::Get()      ->GetDisplayMedia(GetOwner(), aConstraints, aCallerType)      ->Then(GetCurrentThreadSerialEventTarget(), __func__,             [this, self, p](RefPtr<DOMMediaStream>&& aStream) {               if (!GetWindowIfCurrent()) {                 return;  // leave promise pending after navigation.               }               p->MaybeResolve(std::move(aStream));             },             [this, self, p](RefPtr<MediaMgrError>&& error) {               nsPIDOMWindowInner* window = GetWindowIfCurrent();               if (!window) {                 return;  // leave promise pending after navigation.               }               p->MaybeReject(MakeRefPtr<MediaStreamError>(window, *error));             });  return p.forget();}

voidWrapperPromiseCallback::Call(const Optional<JS::Handle<JS::Value> >& aValue){  AutoJSContext cx;  Maybe<JSAutoCompartment> ac;  EnterCompartment(ac, cx, aValue);  ErrorResult rv;  // If invoking callback threw an exception, run resolver's reject with the  // thrown exception as argument and the synchronous flag set.  Optional<JS::Handle<JS::Value> > value(cx,    mCallback->Call(mNextResolver->GetParentObject(), aValue, rv,                    CallbackObject::eRethrowExceptions));  rv.WouldReportJSException();  if (rv.Failed() && rv.IsJSException()) {    Optional<JS::Handle<JS::Value> > value(cx);    rv.StealJSException(cx, &value.Value());    Maybe<JSAutoCompartment> ac2;    EnterCompartment(ac2, cx, value);    mNextResolver->RejectInternal(cx, value, PromiseResolver::SyncTask);    return;  }  // Otherwise, run resolver's resolve with value and the synchronous flag  // set.  Maybe<JSAutoCompartment> ac2;  EnterCompartment(ac2, cx, value);  mNextResolver->ResolveInternal(cx, value, PromiseResolver::SyncTask);}

already_AddRefed<Promise>AudioContext::Close(ErrorResult& aRv){  nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());  nsRefPtr<Promise> promise;  promise = Promise::Create(parentObject, aRv);  if (aRv.Failed()) {    return nullptr;  }  if (mIsOffline) {    promise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR);    return promise.forget();  }  if (mAudioContextState == AudioContextState::Closed) {    promise->MaybeResolve(NS_ERROR_DOM_INVALID_STATE_ERR);    return promise.forget();  }  mCloseCalled = true;  mPromiseGripArray.AppendElement(promise);  Graph()->ApplyAudioContextOperation(DestinationStream()->AsAudioNodeStream(),                                      AudioContextOperation::Close, promise);  MediaStream* ds = DestinationStream();  if (ds) {    ds->BlockStreamIfNeeded();  }  return promise.forget();}

voidWrapperPromiseCallback::Call(const Optional<JS::Handle<JS::Value> >& aValue){  AutoJSContext cx;  // FIXME Bug 878849  Maybe<JSAutoCompartment> ac;  if (aValue.WasPassed() && aValue.Value().isObject()) {    JS::Rooted<JSObject*> rooted(cx, &aValue.Value().toObject());    ac.construct(cx, rooted);  }  ErrorResult rv;  // If invoking callback threw an exception, run resolver's reject with the  // thrown exception as argument and the synchronous flag set.  Optional<JS::Handle<JS::Value> > value(cx,    mCallback->Call(mNextResolver->GetParentObject(), aValue, rv,                    CallbackObject::eRethrowExceptions));  rv.WouldReportJSException();  if (rv.Failed() && rv.IsJSException()) {    Optional<JS::Handle<JS::Value> > value(cx);    rv.StealJSException(cx, &value.Value());    mNextResolver->RejectInternal(cx, value, PromiseResolver::SyncTask);    return;  }  // Otherwise, run resolver's resolve with value and the synchronous flag  // set.  mNextResolver->ResolveInternal(cx, value, PromiseResolver::SyncTask);}

pgCollection *ctlTree::GetParentCollection(wxTreeItemId id){	pgCollection *coll = (pgCollection *)GetParentObject(id);	if (coll && coll->IsCollection())		return coll;	return 0;}

already_AddRefed<MediaKeySession>MediaKeys::CreateSession(JSContext* aCx,                         SessionType aSessionType,                         ErrorResult& aRv){  if (!mProxy) {    NS_WARNING("Tried to use a MediaKeys which lost its CDM");    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);    return nullptr;  }  EME_LOG("MediaKeys[%p] Creating session", this);  RefPtr<MediaKeySession> session = new MediaKeySession(aCx,                                                          GetParentObject(),                                                          this,                                                          mKeySystem,                                                          mCDMVersion,                                                          aSessionType,                                                          aRv);  if (aRv.Failed()) {    return nullptr;  }  // Add session to the set of sessions awaiting their sessionId being ready.  mPendingSessions.Put(session->Token(), session);  return session.forget();}

already_AddRefed<Promise>AudioContext::Resume(ErrorResult& aRv){  nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());  nsRefPtr<Promise> promise;  promise = Promise::Create(parentObject, aRv);  if (aRv.Failed()) {    return nullptr;  }  if (mIsOffline) {    promise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR);    return promise.forget();  }  if (mAudioContextState == AudioContextState::Closed ||      mCloseCalled) {    promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);    return promise.forget();  }  if (mAudioContextState == AudioContextState::Running) {    promise->MaybeResolve(JS::UndefinedHandleValue);    return promise.forget();  }  Destination()->Resume();  mPromiseGripArray.AppendElement(promise);  Graph()->ApplyAudioContextOperation(DestinationStream()->AsAudioNodeStream(),                                      AudioContextOperation::Resume, promise);  return promise.forget();}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CBaseTFVehicle::FinishedBuilding( void ){	BaseClass::FinishedBuilding();	// See if we've finished building on a vehicle that has a passenger slot assigned to my buildpoint.	CBaseObject	*pParent = GetParentObject();	if ( pParent && pParent->IsAVehicle() )	{		CBaseTFVehicle *pVehicle = static_cast<CBaseTFVehicle*>(pParent);		int iRole = pVehicle->GetChildVehicleRole( this );		if ( iRole != -1 )		{			// Is there a player in the role assigned to this buildpoint?			CBaseTFPlayer *pExistingPlayer = static_cast<CBaseTFPlayer*>( pVehicle->GetPassenger( iRole ) );			if ( pExistingPlayer )			{				// Remove the player from my parent vehicle and put them in me				pExistingPlayer->LeaveVehicle();				// Get in the vehicle.				pExistingPlayer->GetInVehicle( this, VEHICLE_DRIVER );			}		}	}}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------bool CBaseObjectDriverGun::ShouldPredict( void ){	CBaseTFVehicle *pVehicle = dynamic_cast<CBaseTFVehicle*>(GetParentObject());	if ( pVehicle && pVehicle->GetDriverPlayer() == C_BasePlayer::GetLocalPlayer() )		return true;	return BaseClass::ShouldPredict();}

FVector FGeomPoly::GetMidPoint() const{	FVector Wk(0,0,0);	int32 Count = 0;	for( int32 e = 0 ; e < EdgeIndices.Num() ; ++e )	{		const FGeomEdge* ge = &GetParentObject()->EdgePool[ EdgeIndices[e] ];		Wk += GetParentObject()->VertexPool[ ge->VertexIndices[0] ];		Count++;		Wk += GetParentObject()->VertexPool[ ge->VertexIndices[1] ];		Count++;	}	check( Count );	return Wk / Count;}

nsCOMPtr<nsIGlobalObject> OffscreenCanvas::GetGlobalObject() {  if (NS_IsMainThread()) {    return GetParentObject();  }  dom::WorkerPrivate* workerPrivate = dom::GetCurrentThreadWorkerPrivate();  return workerPrivate->GlobalScope();}

void FileSystemFileEntry::GetFile(    FileCallback& aSuccessCallback,    const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) const {  RefPtr<FileCallbackRunnable> runnable =      new FileCallbackRunnable(&aSuccessCallback, mFile);  FileSystemUtils::DispatchRunnable(GetParentObject(), runnable.forget());}

already_AddRefed<TouchList> TouchEvent::CopyTouches(    const Sequence<OwningNonNull<Touch>>& aTouches) {  RefPtr<TouchList> list = new TouchList(GetParentObject());  size_t len = aTouches.Length();  for (size_t i = 0; i < len; ++i) {    list->Append(aTouches[i]);  }  return list.forget();}

voidFileReader::OnLoadEndArrayBuffer(){  AutoJSAPI jsapi;  if (!jsapi.Init(GetParentObject())) {    FreeDataAndDispatchError(NS_ERROR_FAILURE);    return;  }  RootResultArrayBuffer();  JSContext* cx = jsapi.cx();  mResultArrayBuffer = JS_NewArrayBufferWithContents(cx, mDataLen, mFileData);  if (mResultArrayBuffer) {    mFileData = nullptr; // Transfer ownership    FreeDataAndDispatchSuccess();    return;  }  // Let's handle the error status.  JS::Rooted<JS::Value> exceptionValue(cx);  if (!JS_GetPendingException(cx, &exceptionValue) ||      // This should not really happen, exception should always be an object.      !exceptionValue.isObject()) {    JS_ClearPendingException(jsapi.cx());    FreeDataAndDispatchError(NS_ERROR_OUT_OF_MEMORY);    return;  }  JS_ClearPendingException(jsapi.cx());  JS::Rooted<JSObject*> exceptionObject(cx, &exceptionValue.toObject());  JSErrorReport* er = JS_ErrorFromException(cx, exceptionObject);  if (!er || er->message()) {    FreeDataAndDispatchError(NS_ERROR_OUT_OF_MEMORY);    return;  }  nsAutoString errorName;  JSFlatString* name = js::GetErrorTypeName(cx, er->exnType);  if (name) {    AssignJSFlatString(errorName, name);  }  nsAutoCString errorMsg(er->message().c_str());  nsAutoCString errorNameC = NS_LossyConvertUTF16toASCII(errorName);  // XXX Code selected arbitrarily  mError =    new DOMException(NS_ERROR_DOM_INVALID_STATE_ERR, errorMsg,                     errorNameC, DOMException_Binding::INVALID_STATE_ERR);  FreeDataAndDispatchError();}

already_AddRefed<Promise>MediaKeys::MakePromise(ErrorResult& aRv){  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());  if (!global) {    NS_WARNING("Passed non-global to MediaKeys ctor!");    aRv.Throw(NS_ERROR_UNEXPECTED);    return nullptr;  }  return Promise::Create(global, aRv);}

already_AddRefed<Promise>AudioContext::DecodeAudioData(const ArrayBuffer& aBuffer,                              const Optional<OwningNonNull<DecodeSuccessCallback> >& aSuccessCallback,                              const Optional<OwningNonNull<DecodeErrorCallback> >& aFailureCallback,                              ErrorResult& aRv){  nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());  RefPtr<Promise> promise;  AutoJSAPI jsapi;  jsapi.Init();  JSContext* cx = jsapi.cx();  JSAutoCompartment ac(cx, aBuffer.Obj());  promise = Promise::Create(parentObject, aRv);  if (aRv.Failed()) {    return nullptr;  }  aBuffer.ComputeLengthAndData();  if (aBuffer.IsShared()) {    // Throw if the object is mapping shared memory (must opt in).    aRv.ThrowTypeError<MSG_TYPEDARRAY_IS_SHARED>(NS_LITERAL_STRING("Argument of AudioContext.decodeAudioData"));    return nullptr;  }  // Detach the array buffer  size_t length = aBuffer.Length();  JS::RootedObject obj(cx, aBuffer.Obj());  uint8_t* data = static_cast<uint8_t*>(JS_StealArrayBufferContents(cx, obj));  // Sniff the content of the media.  // Failed type sniffing will be handled by AsyncDecodeWebAudio.  nsAutoCString contentType;  NS_SniffContent(NS_DATA_SNIFFER_CATEGORY, nullptr, data, length, contentType);  RefPtr<DecodeErrorCallback> failureCallback;  RefPtr<DecodeSuccessCallback> successCallback;  if (aFailureCallback.WasPassed()) {    failureCallback = &aFailureCallback.Value();  }  if (aSuccessCallback.WasPassed()) {    successCallback = &aSuccessCallback.Value();  }  RefPtr<WebAudioDecodeJob> job(    new WebAudioDecodeJob(contentType, this,                          promise, successCallback, failureCallback));  AsyncDecodeWebAudio(contentType.get(), data, length, *job);  // Transfer the ownership to mDecodeJobs  mDecodeJobs.AppendElement(job.forget());  return promise.forget();}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CBaseObjectDriverGun::FinishedBuilding( void ){#if !defined( CLIENT_DLL )	BaseClass::FinishedBuilding();	CBaseTFVehicle *pVehicle = dynamic_cast<CBaseTFVehicle*>(GetParentObject());	Assert( pVehicle );	pVehicle->SetDriverGun( this );#endif}

already_AddRefed<DetailedPromise>MediaKeySession::MakePromise(ErrorResult& aRv, const nsACString& aName){  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());  if (!global) {    NS_WARNING("Passed non-global to MediaKeys ctor!");    aRv.Throw(NS_ERROR_UNEXPECTED);    return nullptr;  }  return DetailedPromise::Create(global, aRv, aName);}