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

 bool is_root() const noexcept
 {
     if (node.expired()) {
         return false;
     }
     return bool{std::dynamic_pointer_cast<node::inu>(node.lock())};
 }

Listener::Listener(const std::weak_ptr<Manager>& manager){
    LOG_ENTER_FUNC("");

    std::string host;
    if(manager.expired()){
        //todo: notify main thread to eventHandler error.
        exit(1);
    }
    this->manager = manager.lock();
    log("3333333333333 this->manager.use_count:",this->manager.use_count());
    std::string tmp;
    int port;
    if(this->manager->getConfig("port", tmp)){
        port = boost::lexical_cast<int>(tmp);
    }
    int backlog;
    if(this->manager->getConfig("backlog", tmp)){
        backlog = boost::lexical_cast<int>(tmp);
    }
    if(this->manager->getConfig("host", tmp)){
        host = tmp;
    }
    this->serverSocket = std::make_shared<ServerSocket>(port, host, backlog);
    LOG_LEAVE_FUNC("");
}

void EventDispatcher::vRemoveListener(const EventType & eType, const std::weak_ptr<void> & eListener)
{
	//If the eListener is dead or there is no eType in the listener list, simply return.
	if (eListener.expired() || pimpl->m_ListenerCallbackLists.find(eType) == pimpl->m_ListenerCallbackLists.end())
		return;

	//If it's dispatching, we should cache this operation and call it after the dispatch.
	if (pimpl->m_IsDispatchingQueue){
		pimpl->m_CachedOperations.emplace_back([this, eType, eListener](){vRemoveListener(eType, eListener); });
		return;
	}

	//Prepare for traversing the listener list.
	const auto strongListener = eListener.lock();
	auto & listenerListOfType = pimpl->m_ListenerCallbackLists[eType];

	//Traverse the listener list to see if there is an listener to be removed.
	//Don't use for(xx:yy) because there is at most one listener to remove from the list. Once we find it, we can simply remove it and return.
	for (auto listenerIter = listenerListOfType.begin(); listenerIter != listenerListOfType.end(); ++listenerIter){
		//If the current listener is dead, ignore it.
		if (listenerIter->first.expired())
			continue;

		//If the current listener "equals" eListener, remove it from the list.
		if (listenerIter->first.lock() == strongListener){
			listenerListOfType.erase(listenerIter);
			return;
		}
	}
}

void touchmind::model::node::NodeModel::RemoveLink(const std::weak_ptr<touchmind::model::link::LinkModel> &link)
{
    m_links.erase(std::remove_if(std::begin(m_links), std::end(m_links),
    [&](std::weak_ptr<touchmind::model::link::LinkModel> e) {
        return !link.expired() && !e.expired() && link.lock()->GetLinkId() == e.lock()->GetLinkId();
    }), std::end(m_links));
}

 /** Creates either a client or server lobby protocol as a singleton. */
 template<typename singleton> static std::shared_ptr<singleton> create()
 {
     assert(m_lobby.expired());
     auto ret = std::make_shared<singleton>();
     m_lobby = ret;
     return std::dynamic_pointer_cast<singleton>(ret);
 }   // create

	// STATIC:
	float PhysicsEntityContainer::getSquaredDistance(std::weak_ptr<PhysicsEntity> e1, 
													 std::weak_ptr<PhysicsEntity> e2)
	{
		// Abort if null pointers
		if(e1.expired() || e2.expired()) return 0;

		// Set the difference between positions in each dimension
		float deltaX = e1._Get()->GetTransform()._Get()->GetPosition().x
			- e2._Get()->GetTransform()._Get()->GetPosition().x;
		float deltaY = e1._Get()->GetTransform()._Get()->GetPosition().y
			- e2._Get()->GetTransform()._Get()->GetPosition().y;
		float deltaZ = e1._Get()->GetTransform()._Get()->GetPosition().z
			- e2._Get()->GetTransform()._Get()->GetPosition().z;

		// Squared distance formula (doesn't use square root)
		return deltaX*deltaX + deltaY*deltaY + deltaZ*deltaZ;
	}

	void GameObject::Destroy(std::weak_ptr<GameObject> &obj)
	{
		if(!obj.expired())
		{
			obj.lock()->Delete();
			obj.reset();
		}
	}

Dispatcher::Dispatcher(const std::weak_ptr<Manager>& manager){
    LOG_ENTER_FUNC("constructor");
    if(manager.expired()){
        exit(1);
    }
    this->manager = manager.lock();
    log("manager.use_count()", this->manager.use_count());
    LOG_LEAVE_FUNC("constructor");
}

void Benchmark::addBenchmark(std::weak_ptr<Benchmark> benchmark)
{
    std::lock_guard<std::recursive_mutex> lock(_benchmarkLock);
    if(benchmark.expired())
        return;

    benchmark.lock()->_parent = this;
    _benchmarks.push_back(benchmark);
}

void SavePlayer2DB(std::weak_ptr<CPlayer> player)
{
    if (!player.expired()&&player.lock()->GetPlayerID()!=0)
    {
        DBPlayer oldPlayerData;
        player.lock()->Player2DB(oldPlayerData);
        DBServer::GetInstance().SavePlayerData(oldPlayerData);
    }
}

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

void LibUSB::DeviceImpl::setParentDevice( std::weak_ptr<Device> pParentDevice )
{

	if (pParentDevice.expired())
	{
		throw std::logic_error("LibUSB::DeviceImpl::setParentDevice() - new parent device pointer is expired.");
	}

	m_ParentDevice = pParentDevice;
}

int CreateUser(const Data& data, std::weak_ptr<CPlayer> player)
{
    if(player.expired())
    {
        return -1;
    }
    std::shared_ptr<CPlayer> playerPtr = player.lock();
    if (playerPtr->GetSocket().expired())
    {
        return -1;
    }
    if (!playerPtr->GetSocket().lock()->GetPlayer().expired())
    {
        PBS2CCreateUserRes res;
        res.set_createuserresult(-1);
        player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CCreateUserRes, res);
        return 0;
    }

    PBC2SCreateUserReq req;
    req.ParseFromArray(data.buffer, data.bufferLength);

    PBS2CCreateUserRes res;
    if (DBServer::GetInstance().CreateUser(player.lock()->GetSocket().lock()->GetLoginID(), req.playername().c_str(), res) != 0)
    {
        return -1;
    }
    DBPlayer playerData;
    if (DBServer::GetInstance().GetPlayerData(playerPtr->GetSocket().lock()->GetLoginID(), playerData) == 0)
    {
        std::weak_ptr<CTCPClientSocket> socket = player.lock()->GetSocket();
        std::weak_ptr<CPlayer> newPlayer = socket.lock()->GetPlayer();
        if (newPlayer.expired())
        {
            newPlayer = PlayerManager::GetInstance().CreatePlayer(playerData.playerid(), socket);
            if (newPlayer.expired())
            {
                return -1;
            }
            newPlayer.lock()->DB2Player(playerData);
            newPlayer.lock()->SetSocket(socket);
            socket.lock()->SetPlayer(newPlayer);
        }
        else
        {
            return -1;
        }
    }
    else
    {
        return -1;
    }
    player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CCreateUserRes, res);
    return 0;
}

int LoginCheck(const Data& data, std::weak_ptr<CPlayer> player)
{
    if(player.expired())
    {
        return -1;
    }
    std::shared_ptr<CPlayer> playerPtr = player.lock();
    if (playerPtr->GetSocket().expired())
    {
        return -1;
    }

    PBC2SLoginCheckReq req;
    req.ParseFromArray(data.buffer, data.bufferLength);

    PBS2CLoginCheckRes res;
    if (DBServer::GetInstance().LoginCheck(req.username().c_str(), req.password().c_str(), res) != 0)
    {
        return -1;
    }
    if (res.logincheckresult() > 0)
    {
        player.lock()->GetSocket().lock()->SetLoginID(res.logincheckresult());
        DBPlayer playerData;
        if (DBServer::GetInstance().GetPlayerData(res.logincheckresult(), playerData) == 0)
        {
            std::weak_ptr<CTCPClientSocket> socket = player.lock()->GetSocket();
            std::weak_ptr<CPlayer> newPlayer = socket.lock()->GetPlayer();
            if (!newPlayer.expired())
            {
                DBPlayer oldPlayerData;
                player.lock()->Player2DB(oldPlayerData);
                DBServer::GetInstance().SavePlayerData(oldPlayerData);
                socket.lock()->SetPlayer(std::weak_ptr<CPlayer>());
                PlayerManager::GetInstance().RemovePlayer(player.lock()->GetPlayerID());
            }
            newPlayer = PlayerManager::GetInstance().CreatePlayer(playerData.playerid(), socket);
            if (newPlayer.expired())
            {
                return -1;
            }
            newPlayer.lock()->DB2Player(playerData);
            newPlayer.lock()->SetSocket(socket);
            socket.lock()->SetPlayer(newPlayer);
        }

    }
    else
    {
        player.lock()->GetSocket().lock()->SetPlayer(std::weak_ptr<CPlayer>());
    }
    player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CLoginCheckRes, res);

    return 0;
}

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