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

            GpsMarkerModule::GpsMarkerModule(Eegeo::Location::ILocationService& locationService,                                             Eegeo::Modules::Map::Layers::TerrainModelModule& terrainModelModule,                                             Eegeo::Modules::Map::MapModule& mapModule,                                             Eegeo::Modules::Core::RenderingModule& renderingModule,                                             Eegeo::Resources::Interiors::InteriorInteractionModel& interiorInteractionModel,                                             VisualMap::SdkModel::IVisualMapService& visualMapService,                                             const bool createBlueSphereViews,                                             ExampleAppMessaging::TMessageBus& messageBus)            : m_renderableFilters(renderingModule.GetRenderableFilters())            {                m_pModel = Eegeo_NEW(GpsMarkerModel)(locationService, interiorInteractionModel, mapModule.GetBlueSphereModule().GetBlueSphereModel());                m_pRingRenderableFactory = AccuracyRingRenderableFactory::Create(renderingModule);                m_pRingRenderable = m_pRingRenderableFactory->BuildRenderable();                m_pRingRenderable->SetColors(Eegeo::v4(18.0f/255.0f, 86.0f/255.0f, 172.0f/255.0f, 0.75f),                                             Eegeo::v4(18.0f/255.0f, 86.0f/255.0f, 172.0f/255.0f, 0.8f));                m_pRingView = Eegeo_NEW(AccuracyRingView)(*m_pRingRenderable);                m_renderableFilters.AddRenderableFilter(*m_pRingView);                m_pController = Eegeo_NEW(GpsMarkerController)(*m_pModel,                                                               interiorInteractionModel,                                                               locationService,                                                               mapModule.GetEnvironmentFlatteningService(),                                                               visualMapService,                                                               mapModule.GetBlueSphereModule().GetBlueSphereView(),                                                               mapModule.GetBlueSphereModule().GetBlueSphereAnchorView(),                                                               createBlueSphereViews,                                                               *m_pRingView,                                                               messageBus);            }

void ModifiedRenderingExample::Start(){	//MyPoolFilterCriteria implemented below... uses camera interest point as selection criteria	m_pCriteria = new ModifiedRenderingExample::MyPoolFilterCriteria(this);	//apply to filter, but lifetime responsibility is ours	m_buildingFilter.SetFilterCriteria(m_pCriteria);	//register for notifications when scene elements are added to or removed from the scene.	m_buildingRepository.AddObserver(*this);	//register as a renderable filter so that we can submit our new renderables for rendering.	m_renderableFilters.AddRenderableFilter(this);	// create alternative material to render with.	m_pAlternativeLighting = Eegeo_NEW(Eegeo::Lighting::GlobalLighting)();	m_pAlternativeShader = Eegeo::Rendering::Shaders::PackedDiffuseShader::Create(m_shaderIdGenerator.GetNextId());	m_pAlternativeMaterial = Eegeo_NEW(Eegeo::Rendering::Materials::PackedDiffuseMaterial)(	                             m_materialIdGenerator.GetNextId(),	                             "ExampleMaterial",	                             *m_pAlternativeShader,	                             *m_pAlternativeLighting,	                             m_placeHolderTexture.textureId,	                             Eegeo::Rendering::TextureMinify_NearestMipmap_Linear,	                             false,	                             false);        PopulateAlternativeRenderablesFromInitialSceneGraph();}

     WatermarkModule::WatermarkModule(Eegeo::Helpers::IIdentityProvider& identityProvider,                                      const std::string& appName,                                      const std::string& googleAnalyticsReferrerToken,                                      Eegeo::Resources::Interiors::InteriorSelectionModel& interiorSelectionModel,                                      Eegeo::Resources::Interiors::InteriorsModelRepository& interiorsModelRepository,                                      InteriorsExplorer::SdkModel::InteriorsExplorerModel& interiorsExplorerModel,                                      ExampleAppMessaging::TMessageBus& messageBus)     {         m_pViewModel = Eegeo_NEW(View::WatermarkViewModel)(identityProvider.GetNextIdentity(), false);                  m_pWatermarkDataFactory = Eegeo_NEW(View::WatermarkDataFactory)(appName, googleAnalyticsReferrerToken);                  m_pWatermarkDataRepository = Eegeo_NEW(View::WatermarkDataRepository)();                  m_pWatermarkDataRepository->AddWatermarkData("eegeo", m_pWatermarkDataFactory->CreateDefaultEegeo());          m_pWatermarkModel = Eegeo_NEW(WatermarkModel)();                  m_pWatermarkInteriorStateChangedObserver = Eegeo_NEW(WatermarkInteriorStateChangedObserver)(*m_pWatermarkModel,                                                                                                     interiorSelectionModel,                                                                                                     interiorsModelRepository,                                                                                                     interiorsExplorerModel,                                                                                                     messageBus);         AddThirdPartyWatermarkData();     }

            WorldMenuController::WorldMenuController(IWorldMenuItemObservable& worldMenuItemObservable                                                     , IWorldMenuItemViewFactory& viewFactory                                                     , Eegeo::UI::IUIInteractionObservable& uiInteractionObservable                                                     , Eegeo::UI::IUICameraProvider& uiCameraProvider                                                     , Eegeo::UI::IUIQuadFactory& quadFactory                                                     , Eegeo::UI::IUIRenderableFilter& uiRenderableFilter                                                     , std::string texture                                                     , int topSpriteID                                                     , int numTilesAlong1Axes)            : m_worldMenuItemRepository(worldMenuItemObservable)            , m_viewFactory(viewFactory)            , m_uiInteractionObservable(uiInteractionObservable)            , m_uiCameraProvider(uiCameraProvider)            {                m_pWorldMenuUpView = Eegeo_NEW(WorldMenuUpView)(quadFactory, uiRenderableFilter, texture, topSpriteID, numTilesAlong1Axes);                m_menuItemsShouldRender = true;                m_isMenuShown = false;                m_worldMenuItemRepository.AddWorldMenuObserver(this);                Eegeo::v2 size(numTilesAlong1Axes,numTilesAlong1Axes);                Eegeo::v2 outMin;                Eegeo::v2 outMax;                Eegeo::UI::CalculateUV(size, 20, outMin, outMax);                Eegeo::v2 dimension = Eegeo::v2(50.f,50.f);                m_pSelectedArrow = Eegeo_NEW(Eegeo::UI::UISprite)(uiRenderableFilter,                                                                  quadFactory.CreateUIQuad(texture,                                                                                           dimension,                                                                                           outMin,                                                                                           outMax,                                                                                           Eegeo::Rendering::LayerIds::Values::AfterAll),                                                                  dimension);                m_pSelectedArrow->SetMaxAlpha(0.5f);            }

void PinsExample::CreateExamplePins(){	// Get the repository of all currently active Pins.	Eegeo::Pins::PinRepository& pinRepository = m_pPinsModule->GetRepository();	// Create test pins and add them to the repository.	Eegeo::Pins::TPinId pin0Id = 0;	Eegeo::Space::LatLong pin0Location = Eegeo::Space::LatLong::FromDegrees(37.7858,-122.401);	int pin0Icon = 0;	Eegeo::Pins::Pin* pPin0 = Eegeo_NEW(Eegeo::Pins::Pin)(pin0Id, pin0Location, 0, pin0Icon, &m_pin0UserData);	pinRepository.AddPin(*pPin0);	// Save this pin so that we can add and remove it in AddRemovePin0()	m_pPin0 = pPin0;	Eegeo::Pins::TPinId pin1Id = 1;	Eegeo::Space::LatLong pin1Location = Eegeo::Space::LatLong::FromDegrees(37.78547,-122.40259);	int pin1Icon = 1;	Eegeo::Pins::Pin* pPin1 = Eegeo_NEW(Eegeo::Pins::Pin)(pin1Id, pin1Location, 0, pin1Icon, &m_pin1UserData);	pinRepository.AddPin(*pPin1);	Eegeo::Pins::TPinId pin2Id = 2;	Eegeo::Space::LatLong pin2Location = Eegeo::Space::LatLong::FromDegrees(37.78547,-122.402);	int pin2Icon = 2;	Eegeo::Pins::Pin* pPin2 = Eegeo_NEW(Eegeo::Pins::Pin)(pin2Id, pin2Location, 0, pin2Icon, &m_pin2UserData);	pinRepository.AddPin(*pPin2);	Eegeo::Pins::TPinId pin3Id = 3;	Eegeo::Space::LatLong pin3Location = Eegeo::Space::LatLong::FromDegrees(37.78547,-122.403);	int pin3Icon = 3;	Eegeo::Pins::Pin* pPin3 = Eegeo_NEW(Eegeo::Pins::Pin)(pin3Id, pin3Location, 30, pin3Icon, &m_pin3UserData);	pinRepository.AddPin(*pPin3);}

            AboutPageMenuModule::AboutPageMenuModule(Menu::View::IMenuViewModel& menuViewModel,                                                   AboutPage::View::IAboutPageViewModel& aboutPageViewModel)            {                m_pAboutPageMenuModel = Eegeo_NEW(Menu::View::MenuModel)();                m_pAboutPageMenuOptionsModel = Eegeo_NEW(Menu::View::MenuOptionsModel)(*m_pAboutPageMenuModel);                m_pAboutPageMenuOptionsModel->AddItem("About", "About", "", "", Eegeo_NEW(View::AboutPageMenuOption)(menuViewModel, aboutPageViewModel));            }

    void PinOverModelExample::Start()    {        pModel = Eegeo::Model::CreateFromPODFile("Test_ROBOT_ARM.pod", fileIO, renderContext.GetGLState(), &textureRequestor, "");        Eegeo_ASSERT(pModel->GetRootNode());        m_pMyModelRenderable = Eegeo_NEW (MyModelRenderable)(*pModel, renderContext, globalFogging, nullMat);        m_pMyRenderableFilter = Eegeo_NEW (MyRenderableFilter)(*m_pMyModelRenderable);        renderableFilters.AddRenderableFilter(m_pMyRenderableFilter);    }

void PinOverModelExample::Start(){	m_pModel = Eegeo::Model::CreateFromPODFile("pin_over_model_example/Test_ROBOT_ARM.pod", m_fileIO, m_renderContext.GetGLState(), &m_textureRequestor, "pin_over_model_example/");	Eegeo_ASSERT(m_pModel->GetRootNode());	m_pMyModelRenderable = Eegeo_NEW (MyModelRenderable)(*m_pModel, m_renderContext, m_globalFogging, m_nullMat);	m_pMyRenderableFilter = Eegeo_NEW (MyRenderableFilter)(*m_pMyModelRenderable);	m_renderableFilters.AddRenderableFilter(m_pMyRenderableFilter);}

            ModalityModule::ModalityModule(ExampleAppMessaging::TMessageBus& messageBus,                                           const std::vector<OpenableControl::View::IOpenableControlViewModel*>& viewModels)            {                m_pModel = Eegeo_NEW(ModalityModel)();                m_pController = Eegeo_NEW(ModalityController)(*m_pModel,                                viewModels);                m_pModalityObserver = Eegeo_NEW(ModalityObserver)(*m_pModel, messageBus);            }

 DecartaSearchServiceModule::DecartaSearchServiceModule(Eegeo::Web::IWebLoadRequestFactory& webLoadRequestFactory,                                                        Eegeo::Helpers::UrlHelpers::IUrlEncoder& urlEncoder) {     m_pSearchResultParser = Eegeo_NEW(Decarta::DecartaSearchJsonParser);          m_pSearchService = Eegeo_NEW(Decarta::DecartaSearchService)(ExampleApp::DecartaApiKey,                                                                 *m_pSearchResultParser,                                                                 urlEncoder,                                                                 webLoadRequestFactory); }

 TwitterFeedService::TwitterFeedService(Eegeo::Web::IWebLoadRequestFactory& webLoadRequestFactory) : m_accessToken("") , m_webLoadRequestFactory(webLoadRequestFactory) , m_pCurrentAuthRequest(NULL) , m_pCurrentTimeLineRequest(NULL) , m_pAuthCallback(Eegeo_NEW(Eegeo::Web::TWebLoadRequestCompletionCallback<TwitterFeedService>)(this, &TwitterFeedService::HandleAuthResponse)) , m_pTimeLineCallback(Eegeo_NEW(Eegeo::Web::TWebLoadRequestCompletionCallback<TwitterFeedService>)(this, &TwitterFeedService::HandleTimeLineResponse)) , m_currentServiceState(NOT_STARTED) {      }

            ModalBackgroundViewModule::ModalBackgroundViewModule(                AndroidNativeState& nativeState,                Modality::View::IModalityModel& modalityModel,                ExampleAppMessaging::TMessageBus& messageBus            )            {                ASSERT_UI_THREAD                m_pView = Eegeo_NEW(ModalBackgroundAggregateView)(nativeState, messageBus);                m_pController = Eegeo_NEW(Modality::View::ModalBackgroundController)(*m_pView, modalityModel);            }

CompassViewModule::CompassViewModule(    WindowsNativeState& nativeState,    ICompassViewModel& viewModel,    ExampleAppMessaging::TMessageBus& messageBus){    m_pView = Eegeo_NEW(CompassView)(nativeState);    m_pController = Eegeo_NEW(CompassController)(                        *m_pView,                        viewModel,                        messageBus);}

			GpsMarkerTutorialViewModule::GpsMarkerTutorialViewModule(WindowsNativeState& nativeState,                                                                     ExampleAppMessaging::TMessageBus& messageBus,                                                                     const GpsMarker::SdkModel::GpsMarkerModel& gpsMarkerModel,                                                                     Eegeo::Rendering::EnvironmentFlatteningService& environmentFlatteningService)			{				m_pView = Eegeo_NEW(GpsMarkerTutorialView)();				m_pController = Eegeo_NEW(GpsMarkerTutorialController)(*m_pView,                                                                       messageBus,                                                                       gpsMarkerModel,                                                                       environmentFlatteningService);			}

            TagSearchViewModule* TagSearchViewModule::Create(                    Menu::View::IMenuOptionsModel& menuOptionsModel,                    Menu::View::IMenuViewModel& menuViewModel,                    ExampleAppMessaging::TMessageBus& messageBus,                    const Menu::View::IMenuReactionModel& menuReaction)            {                auto* pController = Eegeo_NEW(TagSearch::View::TagSearchSectionController)(                        menuOptionsModel,                        menuViewModel,                        messageBus,                        menuReaction);                return Eegeo_NEW(TagSearchViewModule)(pController);            }

 InitialExperienceSearchResultAttractModeModule::InitialExperienceSearchResultAttractModeModule(PersistentSettings::IPersistentSettingsModel& persistentSettings,                                                                                                Menu::View::IMenuViewModel& searchMenuViewModelControl,                                                                                                SearchResultMenu::View::ISearchResultMenuViewModel& searchResultMenuViewModel,                                                                                                ExampleAppMessaging::TMessageBus& messageBus) : m_pInitialExperienceSearchResultAttractModeModel(NULL) , m_pInitialExperienceSearchResultAttractModeViewController(NULL) {          m_pInitialExperienceSearchResultAttractModeModel = Eegeo_NEW(SdkModel::InitialExperienceSearchResultAttractModeModel)(persistentSettings,                                                                                           messageBus);          m_pInitialExperienceSearchResultAttractModeViewController = Eegeo_NEW(View::InitialExperienceSearchResultAttractModeViewController)(searchMenuViewModelControl,                                                                                           searchResultMenuViewModel,                   messageBus); }

	PinsWithAttachedJavaUIExample::PinsWithAttachedJavaUIExample(							Eegeo::EegeoWorld& world,							AndroidNativeState& nativeState,							Eegeo::Rendering::RenderContext& renderContext,                            Eegeo::Helpers::ITextureFileLoader& textureLoader,                            Eegeo::Rendering::GlBufferPool& glBufferPool,                            Eegeo::Rendering::Shaders::ShaderIdGenerator& shaderIdGenerator,                            Eegeo::Rendering::Materials::MaterialIdGenerator& materialIdGenerator,                            Eegeo::Rendering::VertexLayouts::VertexBindingPool& vertexBindingPool,                            Eegeo::Rendering::VertexLayouts::VertexLayoutPool& vertexLayoutPool,                            Eegeo::Rendering::RenderableFilters& renderableFilters,                            const Eegeo::Camera::ICameraProvider& cameraProvider,                            Eegeo::Resources::Terrain::Heights::TerrainHeightProvider& terrainHeightProvider,                            Eegeo::Rendering::EnvironmentFlatteningService& environmentFlatteningService                            )	: m_nativeState(nativeState)	, m_renderContext(renderContext)	, m_world(world)    , m_pinUserData("Pin User Data")    {        textureLoader.LoadTexture(m_pinIconsTexture, "PinIconTexturePage.png", true);        Eegeo_ASSERT(m_pinIconsTexture.textureId != 0);        int numberOfTilesAlongEachAxisOfTexturePage = 2;        m_pPinIconsTexturePageLayout = Eegeo_NEW(Eegeo::Rendering::RegularTexturePageLayout)(        		numberOfTilesAlongEachAxisOfTexturePage);        // The following values specify the size and shape of the Pins within the 3D world.        int spriteWidthInMetres = 100;        int spriteHeightInMetres = 100;        m_pPinsModule = Eegeo_NEW(Eegeo::Pins::PinsModule)(        		m_pinIconsTexture.textureId,        		*m_pPinIconsTexturePageLayout,        		glBufferPool,				shaderIdGenerator,				materialIdGenerator,				vertexBindingPool,				vertexLayoutPool,				renderableFilters,				cameraProvider,				terrainHeightProvider,				spriteWidthInMetres,				spriteHeightInMetres,				Eegeo::Rendering::LayerIds::PlaceNames,				environmentFlatteningService);        CreateExamplePins();    }

 InteriorExplorerState::InteriorExplorerState(AppCamera::SdkModel::IAppCameraController& cameraController,                                              Eegeo::Resources::Interiors::InteriorSelectionModel& interiorSelectionModel,                                              Eegeo::Resources::Interiors::InteriorInteractionModel& interiorInteractionModel,                                              int interiorCameraHandle,                                              Tours::SdkModel::ITourService& tourService,                                              Eegeo::Streaming::CameraFrustumStreamingVolume& cameraFrustumStreamingVolume,                                              InteriorsExplorer::SdkModel::InteriorVisibilityUpdater& interiorVisibilityUpdater,                                              InteriorsExplorer::SdkModel::InteriorsExplorerModel& interiorsExplorerModel,                                              InteriorsExplorer::SdkModel::InteriorExplorerUserInteractionModel& interiorExplorerUserInteractionModel,                                              AppModes::SdkModel::IAppModeModel& appModeModel,                                              Eegeo::Camera::GlobeCamera::GpsGlobeCameraController& worldCameraController,                                              Eegeo::Resources::Interiors::InteriorsCameraController& interiorsCameraController,                                              Eegeo::UI::NativeUIFactories& nativeUIFactories,                                              MyPinCreation::SdkModel::IMyPinCreationModel& myPinCreationModel) : m_tourService(tourService) , m_tourStartedCallback(this, &InteriorExplorerState::OnTourStarted) , m_interiorExplorerUserInteractionModel(interiorExplorerUserInteractionModel) , m_appModeModel(appModeModel) , m_worldCameraController(worldCameraController) , m_interiorsCameraController(interiorsCameraController) , m_nativeUIFactories(nativeUIFactories) , m_failAlertHandler(this, &InteriorExplorerState::OnFailAlertBoxDismissed) , m_myPinCreationModel(myPinCreationModel) , m_lastEntryAttemptSuccessful(false) {          m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerSetupState)(*this,                                                                                                      cameraController,                                                                                                      interiorCameraHandle));          m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerStreamState)(*this,                                                                                                       interiorInteractionModel,                                                                                                       cameraFrustumStreamingVolume,                                                                                                       interiorVisibilityUpdater));          m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerViewingState)(*this,                                                                                                        interiorsExplorerModel,                                                                                                        interiorExplorerUserInteractionModel,                                                                                                        cameraFrustumStreamingVolume));          m_subStates.push_back(Eegeo_NEW(InteriorsExplorer::SdkModel::States::InteriorExplorerExitingState)(*this,                                                                                                        interiorSelectionModel,                                                                                                        cameraFrustumStreamingVolume,                                                                                                        interiorVisibilityUpdater,                                                                                                        interiorsExplorerModel                                                                                                        ));          m_pSubStateMachine = Eegeo_NEW(Helpers::StateMachine)(m_subStates); }

            MyPinCreationDetailsViewModule::MyPinCreationDetailsViewModule(                WindowsNativeState& nativeState,                MyPinCreationDetails::View::IMyPinCreationDetailsViewModel& viewModel,                ExampleAppMessaging::TMessageBus& messageBus,                Metrics::IMetricsService& metricsService            )            {                m_pView = Eegeo_NEW(MyPinCreationDetailsView)(nativeState);                m_pController = Eegeo_NEW(MyPinCreationDetailsController)(*m_pView,                                viewModel,                                messageBus,                                metricsService                                                                         );            }

            MyPinCreationViewModule::MyPinCreationViewModule(                AndroidNativeState& nativeState,                IMyPinCreationInitiationViewModel& initiationViewModel,                IMyPinCreationConfirmationViewModel& confirmationViewModel,                MyPinCreationDetails::View::IMyPinCreationDetailsViewModel& detailsViewModel,                ExampleAppMessaging::TMessageBus& messageBus,                Metrics::IMetricsService& metricsService            )            {                m_pInitiationView = Eegeo_NEW(MyPinCreationInitiationView)(nativeState);                m_pInitiationController = Eegeo_NEW(MyPinCreationInitiationController)(initiationViewModel, *m_pInitiationView, confirmationViewModel, messageBus, metricsService);                m_pConfirmationView = Eegeo_NEW(MyPinCreationConfirmationView)(nativeState);                m_pConfirmationController = Eegeo_NEW(MyPinCreationConfirmationController)(confirmationViewModel, *m_pConfirmationView, detailsViewModel, messageBus, metricsService);            }

            WorldPinItemModel* WorldPinsService::AddPin(IWorldPinSelectionHandler* pSelectionHandler,                                                        IWorldPinVisibilityStateChangedHandler* pVisibilityStateChangedHandler,                                                        const WorldPinFocusData& worldPinFocusData,                                                        const Eegeo::Space::LatLong& location,                                                        int iconIndex)            {                                Eegeo::Pins::Pin* pPin = m_worldPinsFactory.CreatePin(location, iconIndex);                m_pinRepository.AddPin(*pPin);                Eegeo::Pins::TPinId pinId = pPin->GetId();                TPinToSelectionHandlerMapIt pinToSelectionHandlerMapIt = m_pinsToSelectionHandlers.find(pinId);                Eegeo_ASSERT(pinToSelectionHandlerMapIt == m_pinsToSelectionHandlers.end(), "Attempting to add same pin ID %d twice./n", pinId);                m_pinsToSelectionHandlers[pinId] = pSelectionHandler;                                TPinToVisiblityHandlerMapIt pinToVisiblityHandlerMapIt = m_pinsToVisbilityChangedHandlers.find(pinId);                Eegeo_ASSERT(pinToVisiblityHandlerMapIt == m_pinsToVisbilityChangedHandlers.end(), "Attempting to add same pin ID %d twice./n", pinId);                m_pinsToVisbilityChangedHandlers[pinId] = pVisibilityStateChangedHandler;                WorldPinItemModel* model = Eegeo_NEW(WorldPinItemModel)(pinId,                                                                        pSelectionHandler,                                                                        pVisibilityStateChangedHandler,                                                                        worldPinFocusData);                m_worldPinsRepository.AddItem(model);                UpdatePinScale(*model, model->TransitionStateValue());                return model;            }

            void SearchQueryPerformer::HandleSearchResultsResponseReceived(const SearchQuery& query,                    const std::vector<SearchResultModel>& results)            {                // Ideally we should keep merge the new results into the old result set in a stable way, so that the                // result list doesn't jumble up when we move about and perform new searches.                std::map<SearchResultModel, size_t> currentRepoHash;                std::set<size_t> retainedResultIndices;                std::vector<SearchResultModel*> newResultTemporaryStorage;                const int topIndexBeforeAddingNewResult = static_cast<int>(m_searchResultsRepository.GetItemCount() - 1);                // First of all lets map the contents of the results repo so we can easily look results up later.                // Map the result to its index.                for(size_t i = 0; i < m_searchResultsRepository.GetItemCount(); ++ i)                {                    SearchResultModel* pItem = m_searchResultsRepository.GetItemAtIndex(i);                    currentRepoHash.insert(std::make_pair(*pItem, i));                }                // For the new results, check if we already have the result using the map. If so, we flag the results                // index as 'retained'. This will be used later when removing old results. If we have not seen the result                // before, add it to a new temporary vector.                for(std::vector<SearchResultModel>::const_iterator it = results.begin();                        it != results.end();                        ++ it)                {                    std::map<SearchResultModel, size_t>::iterator mapIt = currentRepoHash.find(*it);                    if(mapIt == currentRepoHash.end())                    {                        SearchResultModel* pItem = Eegeo_NEW(SearchResultModel)(*it);                        newResultTemporaryStorage.push_back(pItem);                    }                    else                    {                        retainedResultIndices.insert(mapIt->second);                    }                }                // Walk backwards over the repository removing old results which are not retained, by inspection of                // the retained indices.                for(int i = topIndexBeforeAddingNewResult; i >= 0; --i)                {                    if(retainedResultIndices.find(i) == retainedResultIndices.end())                    {                        SearchResultModel* pItem = m_searchResultsRepository.GetItemAtIndex(i);                        m_searchResultsRepository.RemoveItem(pItem);                        Eegeo_DELETE pItem;                    }                }                // Add the new results on the end after removing the old results.                for(std::vector<SearchResultModel*>::const_iterator it = newResultTemporaryStorage.begin();                        it != newResultTemporaryStorage.end();                        ++ it)                {                    m_searchResultsRepository.AddItem(*it);                }            }

            SearchResultPinBoundObject* SearchResultPinBoundObject::FromSerializedData(MyPinModel::TPinIdType pinId,                                                                                       const std::string& pinMetadataJson,                                                                                       const std::string& pinIconKey,                                                                                       MyPinsFileIO& myPinsFileIO,                                                                                       Search::SdkModel::MyPins::IMyPinsSearchResultRefreshService& myPinsSearchResultRefreshService,                                                                                       ExampleAppMessaging::TMessageBus& messageBus,                                                                                       ExampleAppMessaging::TSdkModelDomainEventBus& sdkModelDomainEventBus,                                                                                       ExampleApp::MyPins::SdkModel::IMyPinsService& myPinsService)            {                Eegeo_ASSERT(!pinIconKey.empty());                Search::SdkModel::SearchResultModel searchResultModel;                                if(!Search::SdkModel::TryDeserializeFromJson(pinMetadataJson, searchResultModel))                {                    return NULL;                }                return Eegeo_NEW(SearchResultPinBoundObject)(pinId,                                                             searchResultModel,                                                             pinIconKey,                                                             myPinsFileIO,                                                             myPinsSearchResultRefreshService,                                                             messageBus,                                                             sdkModelDomainEventBus,                                                             myPinsService);            }

            void SearchResultSectionController::OnSearchQueryResponseReceivedMessage(const Search::SearchQueryResponseReceivedMessage& message)            {                for(int i = 0; i < m_lastAddedResults.size(); ++i)                {                    const Search::SdkModel::SearchResultModel& model(m_lastAddedResults[i]);                    m_menuOptions.RemoveItem(model.GetIdentifier());                }                                m_lastAddedResults = message.GetResults();                //                const std::vector<Search::SdkModel::SearchResultModel>& unorderedResults = message.GetResults();                                OrderWrapper orderWrapper(m_order);                std::stable_sort(m_lastAddedResults.begin(), m_lastAddedResults.end(), orderWrapper);                                for(int i = 0; i < m_lastAddedResults.size(); ++i)                {                    const Search::SdkModel::SearchResultModel& model(m_lastAddedResults[i]);                    m_menuOptions.AddItem(model.GetIdentifier(),                                          model.GetTitle(),                                          model.GetSubtitle(),                                          model.GetCategory(),                                          Eegeo_NEW(SearchResultItemModel)(model.GetTitle(),                                                                           model.GetLocation().ToECEF(),                                                                           model.IsInterior(),                                                                           model.GetBuildingId(),                                                                           model.GetFloor(),                                                                           m_searchMenuViewModel,                                                                           m_messageBus,                                                                           m_menuReaction));                                    }            }

            void InitialExperienceModuleBase::InitialiseWithApplicationModels(WorldAreaLoader::SdkModel::IWorldAreaLoaderModel &worldAreaLoaderModel,                                                                              Menu::View::IMenuViewModel& searchMenuViewModelControl,                                                                              SearchResultMenu::View::ISearchResultMenuViewModel& searchResultMenuViewModel)            {                Eegeo_ASSERT(m_pInitialExperienceModel == NULL, "Cannot call InitialExperienceModule::InitialiseWithApplicationModels twice./n");                std::vector<IInitialExperienceStep*> steps = CreateSteps(worldAreaLoaderModel,                                                                         searchMenuViewModelControl,                                                                         searchResultMenuViewModel);                const int lastCameraLockedStep = 1;                                m_pInitialExperienceModel = Eegeo_NEW(InitialExperienceModel)(steps, lastCameraLockedStep);                m_pInitialExperienceController = Eegeo_NEW(InitialExperienceController)(*m_pInitialExperienceModel);            }

            SearchResultMenuModule::SearchResultMenuModule(Search::SdkModel::ISearchResultRepository& searchResultRepository,                    Search::SdkModel::ISearchQueryPerformer& searchQueryPerformer,                    Eegeo::Helpers::IIdentityProvider& identityProvider,                    CameraTransitions::SdkModel::ICameraTransitionController& cameraTransitionController,                    Reaction::View::IReactionControllerModel& reactionControllerModel,                    ExampleAppMessaging::TMessageBus& messageBus)            {                m_pModel = Eegeo_NEW(Menu::View::MenuModel)();                m_pMenuOptionsModel = Eegeo_NEW(Menu::View::MenuOptionsModel)(*m_pModel);                m_pViewModel = Eegeo_NEW(View::SearchResultMenuViewModel)(*m_pModel,                               false,                               identityProvider.GetNextIdentity(),                               reactionControllerModel);                m_pMenuSection = Eegeo_NEW(Menu::View::MenuSectionViewModel)("Search", "search", *m_pModel, false);                m_pViewModel->AddSection(*m_pMenuSection);                m_pSearchResultRepositoryObserver = Eegeo_NEW(View::SearchResultRepositoryObserver)(                                                        searchResultRepository,                                                        messageBus                                                    );                m_pSearchResultMenuItemSelectedMessageHandler = Eegeo_NEW(SearchResultMenuItemSelectedMessageHandler)(                            cameraTransitionController,                            messageBus                        );                m_pSearchResultAddRemoveHandler = Eegeo_NEW(View::SearchResultAddRemoveHandler)(                                                      *m_pMenuOptionsModel,                                                      *m_pViewModel,                                                      messageBus                                                  );                m_pSearchResultMenuSearchQueryPerformedMessageHandler = Eegeo_NEW(View::SearchResultMenuSearchQueryPerformedMessageHandler)(                            *m_pViewModel,                            messageBus                        );                m_pSearchResultMenuSearchQueryRemovedMessageHandler = Eegeo_NEW(View::SearchResultMenuSearchQueryRemovedMessageHandler)(                            *m_pViewModel,                            messageBus                        );                m_pSearchResultViewClearedObserver = Eegeo_NEW(SearchResultViewClearedObserver)(searchQueryPerformer, messageBus);            }

 void SecondaryMenuModule::AddMenuSection(const std::string& name,                                          Menu::View::IMenuModel& menuModel,                                          bool isExpandable) {     Menu::View::MenuSectionViewModel* pMenuSection = Eegeo_NEW(Menu::View::MenuSectionViewModel)(name, "", menuModel, isExpandable);     m_pViewModel->AddSection(*pMenuSection);     m_sections.push_back(pMenuSection); }

 IGeoNamesSearchQuery* GeoNamesSearchQueryFactory::CreateGeoNamesSearchForQuery(const SdkModel::SearchQuery& query,                                                                                Eegeo::Helpers::ICallback0& completionCallback) {     return Eegeo_NEW(GeoNamesSearchQuery)(m_webRequestFactory,                                           m_urlEncoder,                                           query,                                           completionCallback); }

            std::vector<IInitialExperienceStep*> AndroidInitialExperienceModule::CreateSteps(WorldAreaLoader::SdkModel::IWorldAreaLoaderModel& worldAreaLoaderModel)            {                std::vector<IInitialExperienceStep*> steps;                IInitialExperienceStep* pIntroStep = Eegeo_NEW(InitialExperienceIntroStep)(m_messageBus, GetPersistentSettings());                steps.push_back(pIntroStep);                IInitialExperienceStep* pWorldAreaLoaderStep = Eegeo_NEW(PreLoad::SdkModel::AndroidInitialExperiencePreLoadModel)(                            m_nativeState,                            worldAreaLoaderModel,                            GetPersistentSettings()                        );                steps.push_back(pWorldAreaLoaderStep);                return steps;            }

            MyPinCreationDetailsViewModule::MyPinCreationDetailsViewModule(                AndroidNativeState& nativeState,                MyPinCreationDetails::View::IMyPinCreationDetailsViewModel& viewModel,                Eegeo::Web::IConnectivityService& connectivityService,                ExampleAppMessaging::TMessageBus& messageBus,                Metrics::IMetricsService& metricsService            )            {                m_pView = Eegeo_NEW(MyPinCreationDetailsView)(nativeState);                m_pController = Eegeo_NEW(MyPinCreationDetailsController)(*m_pView,                                viewModel,                                connectivityService,                                messageBus,                                metricsService                                                                         );            }