MainWindow::MainWindow(const nglContextInfo& rContextInfo, const nglWindowInfo& rInfo, bool ShowFPS, const nglContext* pShared ) : nuiMainWindow(rContextInfo, rInfo, pShared, nglPath(ePathCurrent)), nuiNotificationObserver(), mEventSink(this) { mpThread1 = NULL; mpThread2 = NULL; RegisterObserver(NOTIF_PING, this); RegisterObserver(NOTIF_PONG, this); }
status_t BnRTCNode::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case kIDTransport: { rtc_binder_data_t out; out.data = &data; out.reply = reply; // Reserved 4 bytes; reply->writeInt32(0); int ret = Transport(&out); int pos = reply->dataPosition(); reply->setDataPosition(0); reply->writeInt32(ret); reply->setDataPosition(pos); return NO_ERROR; } break; case kIDResigerObs: { CHECK_INTERFACE(IRTCNode, data, reply); sp<IBinder> handle = data.readStrongBinder(); sp<IRTCNode> node = interface_cast<IRTCNode>(handle); int ret = RegisterObserver(node); reply->writeInt32(ret); return NO_ERROR; }break; default: return BBinder::onTransact(code, data, reply, flags); } }
void Transport::InitTCPStack(const Peer &_peer) { assert(s_IsPlatformInit); m_tcpMode = true; // create stream TCPStream *tcpstream = new TCPStream(_peer); if(_peer.GetPort() != 0) { tcpstream->CreateAndBind(); } else { tcpstream->Init(); } // m_streams.push_back(tcpstream); // create listener - note: we do not need reliable listener on tcp UnreliableListener *unreliablelistener = new UnreliableListener(); m_listeners.push_back(unreliablelistener); // attach tcpstream->AttachListener(*unreliablelistener); RegisterObserver(m_observer); }
CTransDataSubject::CTransDataSubject() { m_recvPos = 0; m_fillPos = 0; for (int i = 0; i<MAX_OBERSERVER_NUM; i++) m_pOberverBuff[i] = NULL; m_curOberserverNum = 0; //逐个注册观察者 m_pOberserverHandler = new CCurrentStatue(); RegisterObserver(m_pOberserverHandler); m_pOberserverHandler = new CAutoCtrl(); RegisterObserver(m_pOberserverHandler); m_pOberserverHandler = new CWaterCtrl(); RegisterObserver(m_pOberserverHandler); m_pOberserverHandler = new CHotCtrl(); RegisterObserver(m_pOberserverHandler); m_pOberserverHandler = new CLightCtrl(); RegisterObserver(m_pOberserverHandler); m_pOberserverHandler = new CModeCtrl(); RegisterObserver(m_pOberserverHandler); m_pOberserverHandler = new CWindCtrl(); RegisterObserver(m_pOberserverHandler); }
uint8_t QICMotionCapture::CreateMotionStream(StreamsManager *pSM, string streamName) { // 1. create video stream for application // video stream is created here but deleting in BaseV4L2VideoCapture because video stream is relevant to hardware device QICMotionStream *pStream = new QICMotionStream(pSM, streamName); // 2. register video stream as carrier for receiving data RegisterCarrier((IDeviceCarrier *)pStream); // 3. register video stream as observer for obtaining notification RegisterObserver((IDeviceObserver *)pStream); return 1; }
// Called when the game starts void UBrainObservable::BeginPlay() { Super::BeginPlay(); FScriptDelegate Delegate, Delegate2; Delegate.BindUFunction(this, "OnActorCollisionBegin"); Delegate2.BindUFunction(this, "OnActorCollisionEnd"); GetOwner()->OnActorBeginOverlap.Add(Delegate); GetOwner()->OnActorEndOverlap.Add(Delegate2); for (int32 i = 0; i < _list.Num(); i++){ AActor* actor = _list[i]; UBrainObserver* ub = actor->FindComponentByClass<UBrainObserver>(); if (ub != nullptr) RegisterObserver(ub); } }
void Transport::InitUDPStack(const Peer &_peer) { assert(s_IsPlatformInit); m_tcpMode = false; // create stream UDPStream *udpstream = new UDPStream(_peer); udpstream->CreateAndBind(); m_streams.push_back(udpstream); // create listener UnreliableListener *unreliablelistener = new UnreliableListener(); m_listeners.push_back(unreliablelistener); ReliableListener *reliablelistener = new ReliableListener(); m_listeners.push_back(reliablelistener); // attach udpstream->AttachListener(*unreliablelistener); udpstream->AttachListener(*reliablelistener); RegisterObserver(m_observer); }
bool UMyBlackboardComponent::PushBlackboard(UBlackboardData* NewAsset, TArray<struct FBlackboardKeySelector> &Params) { UAISystem* AISystem = UAISystem::GetCurrentSafe(GetWorld()); if (AISystem == nullptr) { return false; } //makes a copy of the blackboard //otherwise the data in the bb can be owerwritten by other calls or other instances UBlackboardData* NewAssetCopy = CopyBlackboardData(NewAsset); //save current bb on stack BBStack.Add(BlackboardAsset); UBlackboardData* OldAsset = BlackboardAsset; //and replace it by new bb BlackboardAsset = NewAssetCopy; bool bSuccess = true; const int32 NumKeys = NewAssetCopy->Keys.Num(); //make old bb parent of new bb NewAssetCopy->Parent = OldAsset; //update first key id accordingly NewAssetCopy->UpdateKeyIDs(); TArray<FBlackboardInitializationData> InitList; InitList.Reserve(NumKeys); //grow ValueOffsets to contain new bb offsets ValueOffsets.AddZeroed(NumKeys); for (int32 KeyIndex = 0; KeyIndex < NumKeys; KeyIndex++) { if (NewAssetCopy->Keys[KeyIndex].KeyType) { InitList.Add(FBlackboardInitializationData(KeyIndex + NewAssetCopy->GetFirstKeyID(), NewAssetCopy->Keys[KeyIndex].KeyType->GetValueSize())); } } // sort key values by memory size, so they can be packed better // it still won't protect against structures, that are internally misaligned (-> uint8, uint32) // but since all Engine level keys are good... InitList.Sort(FBlackboardInitializationData::FMemorySort()); uint16 MemoryOffset = 0; for (int32 Index = 0; Index < InitList.Num(); Index++) { ValueOffsets[InitList[Index].KeyID] = MemoryOffset + ValueMemory.Num(); MemoryOffset += InitList[Index].DataSize; } //grow ValueMemory to contain new bb data //(also allows memory for parameters, this is not really neaded, to improve...) ValueMemory.AddZeroed(MemoryOffset); // initialize memory for (int32 Index = 0; Index < InitList.Num(); Index++) { const FBlackboardEntry* KeyData = BlackboardAsset->GetKey(InitList[Index].KeyID); uint8* RawData = GetKeyRawData(InitList[Index].KeyID); KeyData->KeyType->Initialize(RawData); } int32 ParamIndex = 0; for (int32 KeyIndex = 0; KeyIndex < NumKeys && ParamIndex<Params.Num(); KeyIndex++) { //for each parameter if (NewAssetCopy->Keys[KeyIndex].KeyType&&NewAssetCopy->Keys[KeyIndex].EntryName.ToString().StartsWith("PARAM_")) { FBlackboard::FKey ParentKeyID = OldAsset->GetKeyID(Params[ParamIndex].SelectedKeyName); FBlackboard::FKey ChildKeyID = BlackboardAsset->GetKeyID(BlackboardAsset->Keys[KeyIndex].EntryName); if (ParentKeyID != FBlackboard::InvalidKey && ChildKeyID != FBlackboard::InvalidKey) { //redirect ValueOffset to the memory location of the actual argument ValueOffsets[ChildKeyID] = ValueOffsets[ParentKeyID]; //add observer to propagate notifications to actual argument observers DelegateHandles.Add(FMyKeyDelegate(ChildKeyID, RegisterObserver(ChildKeyID, this, FOnBlackboardChange::CreateLambda([this, ParentKeyID](const UBlackboardComponent& BComp, FBlackboard::FKey ChangedKeyID){ this->CallNotifyObservers(ParentKeyID); })))); ParamIndex++; } } } //saves number of parameters found ParamsNumStack.Add(ParamIndex); return bSuccess; }