C++ weak_ptr::lock方法代码示例

void EventHandler::add(std::weak_ptr<EventHandled> handler)
{
   auto fd_ptr = handler.lock();

   for (auto fd : fd_ptr->pollfds())
   {
      struct epoll_event event{};
      event.events = fd.events;
      event.data.fd = fd.fd;

      cb_map[event.data.fd] = [this, handler]() {
         if (auto tmp = handler.lock())
            tmp->handle(*this);
      };

      if (epoll_ctl(epfd, EPOLL_CTL_ADD, event.data.fd, &event) < 0)
         throw std::runtime_error("Failed to add epoll fd to list.\n");
   }
}

 /** Returns the singleton client or server lobby protocol. */
 template<class T> static std::shared_ptr<T> get()
 {
     if (std::shared_ptr<LobbyProtocol> lp = m_lobby.lock())
     {
         std::shared_ptr<T> new_type = std::dynamic_pointer_cast<T>(lp);
         if (new_type)
             return new_type;
     }
     return nullptr;
 }   // get

void Connection::handleWriteTimeout(std::weak_ptr<Connection> weak, const boost::system::error_code& error)
{
	if(error == boost::asio::error::operation_aborted || weak.expired())
		return;

	if(std::shared_ptr<Connection> connection = weak.lock())
	{
		connection->onWriteTimeout();
	}
}

std::shared_ptr<vector<string>> ConstStrBlobPtr::check(
    std::size_t pos, const string& msg) const {
    // test to see whether the vector pointed by the weak_ptr is still around
    auto ptr = dataptr.lock();
    if(!ptr)
        throw std::runtime_error("unbound ConstStrBlobPtr");
    if(pos >= ptr->size())
        throw std::out_of_range(msg);
    return ptr;
}

  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";
  }

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

	mWeakRenderer = renderer;
	return true;
}

std::shared_ptr<std::vector<std::string>> StrBlobPtr::check(
    std::size_t i, const std::string &msg) const {
  auto ret = wptr.lock();
  if (!ret) {
    throw std::runtime_error("unbound StrBlobPtr");
  }
  if (i >= ret->size()) {
    throw std::out_of_range(msg);
  }
  return ret;
}

static void av_qsv_log_callback(void *ptr, int level, const char *fmt, va_list vl) {
    if (auto pQSVLog = g_pQSVLog.lock()) {
        const int qsv_log_level = log_level_av2rgy(level);
        if (qsv_log_level >= pQSVLog->getLogLevel() && pQSVLog->logFileAvail()) {
            char mes[4096];
            av_log_format_line(ptr, level, fmt, vl, mes, sizeof(mes), &print_prefix);
            pQSVLog->write_log(qsv_log_level, char_to_tstring(mes, CP_UTF8).c_str(), true);
        }
    }
    av_log_default_callback(ptr, level, fmt, vl);
}

	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_;
		}
	}

/* Notes *
    * std::weak_ptr *
    expired - checks whether the referenced object was already deleted
    lock    - creates a shared_ptr that manages the referenced object 

    * std::unique_ptr * ,using this instead of auto_ptr considering:
    1 - operators supported(==, !=, < ...),so they can be used/stored in STL
        which uses/relies on a lot of these operations
    2 - array supported, can point to an array
*/
void f()
{
    if ( !wp.expired()) {
        auto spt = wp.lock();
        std::cout << *spt << "\n";
        std::cout << wp.use_count() << "\n";
    }
    else {
        std::cout << "wp is expired\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;
}

    void log_gl_error(const gl_error& error)
    {
        std::shared_ptr<context> current_locked_context = current_context.lock();
        if (current_locked_context && current_locked_context->state().error() == GL_NO_ERROR)
        {
            current_locked_context->state().error() = error.error_code();
        }

        log_message(GL_DEBUG_SOURCE_API_KHR, GL_DEBUG_TYPE_ERROR_KHR, error.error_code(), GL_DEBUG_SEVERITY_HIGH_KHR,
                    format("%s: %s", error.error_code_description().c_str(), error.error_msg().c_str()));
    }

 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));
         
     }
 }

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);
	}
}

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;
    }
}