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 MAVConnTCPServer::client_closed(std::weak_ptr<MAVConnTCPClient> weak_instp)
{
	if (auto instp = weak_instp.lock()) {
		bool locked = mutex.try_lock();
		logInform(PFXd "Client connection closed, id: %p, address: %s",
				conn_id, instp.get(), to_string_ss(instp->server_ep).c_str());

		client_list.remove(instp);

		if (locked)
			mutex.unlock();
	}
}

 std::weak_ptr<vertex> go (char c) {
     std::weak_ptr<vertex> next;
     auto itr = children.find(c);
     if (itr != children.end()) {
         next = itr->second;
     } else {
         if (parent.lock().get() == NULL) {
                 next = root;
             }
             else next = get_link().lock()->go(c);
     }
     return next;
 }

 void CloudResource::onCloudProvResponseSafetyCb(const HeaderOptions& headerOptions,
                                                         const OCRepresentation& rep,
                                                         const int eCode,
                                                         ESCloudResourceCb cb,
                                                         std::weak_ptr<CloudResource> this_ptr)
 {
     OIC_LOG(DEBUG, ES_CLOUD_RES_TAG, "onCloudProvResponseSafetyCb");
     std::shared_ptr<CloudResource> Ptr = this_ptr.lock();
     if(Ptr)
     {
         cb(headerOptions, rep, eCode);
     }
 }

KeyFrameAnimationState::KeyFrameAnimationState(std::weak_ptr<KeyFrameAnimated> animatable, AnimationUpdatedCallback refresh_animation_state):
    animatable_(animatable),
    refresh_animation_state_(refresh_animation_state) {

    auto anim = animatable_.lock();
    on_animation_added_ = anim->signal_animation_added().connect(
        [this](KeyFrameAnimated* animatable, const std::string& name) {
            if(animatable->animation_count() == 1) {
                play_animation(name);
            }
        }
    );
}

std::shared_ptr<CAnimTreeNode> CMetaTransPhaseTrans::VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a,
                                                                        const std::weak_ptr<CAnimTreeNode>& b,
                                                                        const CAnimSysContext& animSys) const {
  std::shared_ptr<CAnimTreeNode> nA = a.lock();
  CAnimTreeEffectiveContribution cA = nA->GetContributionOfHighestInfluence();
  std::shared_ptr<CAnimTreeNode> nB = b.lock();
  CAnimTreeEffectiveContribution cB = nB->GetContributionOfHighestInfluence();
  float y2A = cA.GetSteadyStateAnimInfo().GetDuration() / cB.GetSteadyStateAnimInfo().GetDuration();
  float y1B = cB.GetSteadyStateAnimInfo().GetDuration() / cA.GetSteadyStateAnimInfo().GetDuration();

  nB->VSetPhase(zeus::clamp(0.f, 1.f - cA.GetTimeRemaining() / cA.GetSteadyStateAnimInfo().GetDuration(), 1.f));
  auto tsA = std::make_shared<CAnimTreeTimeScale>(
      a, std::make_unique<CLinearAnimationTimeScale>(CCharAnimTime{}, 1.f, x4_transDur, y2A), x4_transDur,
      CAnimTreeTimeScale::CreatePrimitiveName(a, 1.f, x4_transDur, y2A));
  auto tsB = std::make_shared<CAnimTreeTimeScale>(
      b, std::make_unique<CLinearAnimationTimeScale>(CCharAnimTime{}, y1B, x4_transDur, 1.f), x4_transDur,
      CAnimTreeTimeScale::CreatePrimitiveName(b, y1B, x4_transDur, 1.f));

  return std::make_shared<CAnimTreeTransition>(
      xc_, tsA, tsB, x4_transDur, xd_runA, x10_flags,
      CAnimTreeTransition::CreatePrimitiveName(tsA, tsB, x4_transDur.GetSeconds()));
}

int GetHeroInfo(const Data& data, std::weak_ptr<CPlayer> player)
{
    if (!SendCheck(player))
    {
        return -1;
    }
    PBC2SGetHeroInfoReq req;
    req.ParseFromArray(data.buffer, data.bufferLength);

    std::weak_ptr<CHero> p = player.lock()->GetHeroData().GetHeroPack().GetHero(req.heroindex());
    if (p.expired())
    {
        return -1;
    }

    PBS2CGetHeroInfoRes res;

    p.lock()->HeroInfo2PB(*res.mutable_heroinfo());
    res.set_getheroinforesult(0);
    player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CGetHeroInfoRes, res);
    return 0;
}

int LoginRegister(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;
    }

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

    PBS2CLoginRegisterRes res;
    if (DBServer::GetInstance().LoginRegister(req.username().c_str(), req.password().c_str(), res) != 0)
    {
        return -1;
    }
    player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CLoginRegisterRes, res);
    return 0;
}