C++ std::weak_ptr类代码示例

	void initialize(std::weak_ptr<scoped_signal_mask>& sigmask_wptr)
	{
		static std::mutex mutex_;
		std::lock_guard<std::mutex> lk(mutex_);
		sigmask_sptr_ = sigmask_wptr.lock();
		if (!sigmask_sptr_) {
			signal_set sigset{ SignalNumber... };
			sigmask_sptr_ = std::make_shared<scoped_signal_mask>(sigset);
			sigmask_wptr = sigmask_sptr_;
		}
	}

 void
 GenericAudioMixer::setSourceGain(std::weak_ptr<ISource> source, float gain)
 {
     auto s = source.lock();
     if(s) {
         auto hash = std::hash<std::shared_ptr<ISource>>()(s);
         
         m_inGain[hash] = std::max(0.f, std::min(1.f, gain));
         
     }
 }

//------------------------------------------//
// Texture2DAssetLoader::StartupLoader				
//------------------------------------------//
bool Texture2DAssetLoader::StartupLoader(std::weak_ptr<class Renderer> renderer)
{
	if (renderer.lock() == nullptr)
	{
		//Fail something
		return false;
	}

	mWeakRenderer = renderer;
	return true;
}

void ConstraintComponent::setAssociatedNode(std::weak_ptr<kitsune::scenegraph::Node> AssociatedNode)
{
	auto associated = AssociatedNode.lock();
	if (!associated)
		return;

	associatedNodeComponentAddedListener = associated->addComponentAddedEvent(std::bind(&ConstraintComponent::onNodeAddComponent, this, std::placeholders::_1));
	associatedNodeComponentRemovedListener = associated->addComponentRemovedEvent(std::bind(&ConstraintComponent::onNodeRemoveComponent, this, std::placeholders::_1));

	createConstraint();
}

void memory_pool::return_to_pool(const std::weak_ptr<memory_pool> &self_weak, std::uint8_t *ptr)
{
    std::shared_ptr<memory_pool> self = self_weak.lock();
    if (self)
        self->return_to_pool(ptr);
    else
    {
        log_debug("dropping memory because the pool has been freed");
        delete[] ptr;
    }
}

void Renderable2DBox::Render(std::weak_ptr<const RendererBase> renderer) const
{
	std::shared_ptr<const RendererBase> rendererShared = renderer.lock();
	if (rendererShared != nullptr)
	{
		rendererShared->DrawColoredLine(m_Points[0], m_Points[2], m_Color);
		rendererShared->DrawColoredLine(m_Points[2], m_Points[3], m_Color);
		rendererShared->DrawColoredLine(m_Points[3], m_Points[1], m_Color);
		rendererShared->DrawColoredLine(m_Points[1], m_Points[0], m_Color);
	}
}

	// STATIC:
	void PhysicsEntityContainer::Add(std::weak_ptr<PhysicsEntity> newObject)
	{
		// Was this initalized
		if(!PhysicsEntityContainer::verifyInstantiation()) return;
		
		// Check if the pointer is empty
		if(newObject.expired()) return;

		// Add it
		PhysicsEntityContainer::_instance->_listOfContainedObjects.push_front(newObject);
	}

 std::experimental::optional<T> get(std::weak_ptr<handle<T>> handle_wp)
 {
   auto hid_sp = handle_wp.lock();
   if (!hid_sp) {
     return std::experimental::optional<T>{};
   }
   handle<T>* hid = hid_sp.get();
   if(handle_map[hid->index] != hid_sp){
     return std::experimental::optional<T>{};
   }
   return std::experimental::make_optional(container[hid->index]);
 }

 nCursesProgressWindow::nCursesProgressWindow(std::weak_ptr<Window> parentWnd){
     LOG("Progress window constructor : ", this);
     if(auto spTmp = parentWnd.lock()){
         parentWindow = parentWnd;
         posx = spTmp->getRows()-1;
         posy = spTmp->getColumns() - width;
         file_size = dynamic_cast<nCursesDisplayWindow*>(&*spTmp)->file_size;
         nCursesWhnd = ::newwin(height, width, posx, posy);
         ::box(nCursesWhnd, 0, 0);
     }else
         throw miniReader::Exception::miniRuntimeException( __FILE__, ":", __LINE__, "Error creating object", this);
 }

int GetPlayerList(const Data& data, std::weak_ptr<CPlayer> player)
{
    if (!SendCheck(player))
    {
        return -1;
    }
    PBS2CGetPlayerListRes res;
    res.set_getplayerlistresult(0);
    PlayerManager::GetInstance().PlayerList2PB(res);
    player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CGetPlayerListRes, res);
    return 0;
}

void ms::SurfaceStack::destroy_surface(std::weak_ptr<ms::Surface> const& surface)
{
    {
        std::lock_guard<std::mutex> lg(guard);

        auto const p = std::find(surfaces.begin(), surfaces.end(), surface.lock());

        if (p != surfaces.end()) surfaces.erase(p);
        // else; TODO error logging
    }

    emit_change_notification();
}

std::function<void(folly::dynamic)> makeCallback(
    std::weak_ptr<Instance> instance, const folly::dynamic& callbackId) {
  if (!callbackId.isInt()) {
    throw std::invalid_argument("Expected callback(s) as final argument");
  }

  auto id = callbackId.getInt();
  return [winstance = std::move(instance), id](folly::dynamic args) {
    if (auto instance = winstance.lock()) {
      instance->callJSCallback(id, std::move(args));
    }
  };
}

	void model::move_creature
		(const std::weak_ptr<creature>& c, int x, int y)
	{
		std::shared_ptr<creature> csp(c.lock());

		if (!csp)
		{
			std::cerr << "Invalid creature for movement." << std::endl;
			throw invalid_parameter();
		}

		map_.move_creature(csp, x, y);
	}

  void visitModuleFile(StringRef Filename,
                       serialization::ModuleKind Kind) override {
    auto *File = CI.getFileManager().getFile(Filename);
    assert(File && "missing file for loaded module?");

    // Only rewrite each module file once.
    if (!Rewritten.insert(File).second)
      return;

    serialization::ModuleFile *MF =
        CI.getModuleManager()->getModuleManager().lookup(File);
    assert(File && "missing module file for loaded module?");

    // Not interested in PCH / preambles.
    if (!MF->isModule())
      return;

    auto OS = Out.lock();
    assert(OS && "loaded module file after finishing rewrite action?");

    (*OS) << "#pragma clang module build ";
    if (isValidIdentifier(MF->ModuleName))
      (*OS) << MF->ModuleName;
    else {
      (*OS) << '"';
      OS->write_escaped(MF->ModuleName);
      (*OS) << '"';
    }
    (*OS) << '\n';

    // Rewrite the contents of the module in a separate compiler instance.
    CompilerInstance Instance(CI.getPCHContainerOperations(),
                              &CI.getPreprocessor().getPCMCache());
    Instance.setInvocation(
        std::make_shared<CompilerInvocation>(CI.getInvocation()));
    Instance.createDiagnostics(
        new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
        /*ShouldOwnClient=*/true);
    Instance.getFrontendOpts().DisableFree = false;
    Instance.getFrontendOpts().Inputs.clear();
    Instance.getFrontendOpts().Inputs.emplace_back(
        Filename, InputKind(InputKind::Unknown, InputKind::Precompiled));
    Instance.getFrontendOpts().ModuleFiles.clear();
    Instance.getFrontendOpts().ModuleMapFiles.clear();
    // Don't recursively rewrite imports. We handle them all at the top level.
    Instance.getPreprocessorOutputOpts().RewriteImports = false;

    llvm::CrashRecoveryContext().RunSafelyOnThread([&]() {
      RewriteIncludesAction Action;
      Action.OutputStream = OS;
      Instance.ExecuteAction(Action);
    });

    (*OS) << "#pragma clang module endbuild /*" << MF->ModuleName << "*/\n";
  }

static std::shared_ptr<UDTSession> getUDTSession(void)
{
    //TODO needs a lock
    std::shared_ptr<UDTSession> sess = UDTWeakSession.lock();
    if (not sess)
    {
        sess.reset(new UDTSession());
        UDTWeakSession = sess;
    }
    return sess;
}