Example #1
0
  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";
  }
Example #2
0
int main()
{
    static_assert(( std::is_convertible<std::weak_ptr<A>, std::weak_ptr<B> >::value), "");
    static_assert((!std::is_convertible<std::weak_ptr<B>, std::weak_ptr<A> >::value), "");
    static_assert((!std::is_convertible<std::weak_ptr<A>, std::weak_ptr<C> >::value), "");
    {
        const std::weak_ptr<A> pA(std::shared_ptr<A>(new A));
        assert(pA.use_count() == 0);
        assert(B::count == 0);
        assert(A::count == 0);
        {
            std::weak_ptr<B> pB(pA);
            assert(B::count == 0);
            assert(A::count == 0);
            assert(pB.use_count() == 0);
            assert(pA.use_count() == 0);
        }
        assert(pA.use_count() == 0);
        assert(B::count == 0);
        assert(A::count == 0);
    }
    assert(B::count == 0);
    assert(A::count == 0);
    {
        std::weak_ptr<A> pA;
        assert(pA.use_count() == 0);
        assert(B::count == 0);
        assert(A::count == 0);
        {
            std::weak_ptr<B> pB(pA);
            assert(B::count == 0);
            assert(A::count == 0);
            assert(pB.use_count() == 0);
            assert(pA.use_count() == 0);
        }
        assert(pA.use_count() == 0);
        assert(B::count == 0);
        assert(A::count == 0);
    }
    assert(B::count == 0);
    assert(A::count == 0);
}
	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_;
		}
	}
Example #4
0
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
 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));
         
     }
 }
Example #6
0
    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()));
    }
//------------------------------------------//
// Texture2DAssetLoader::StartupLoader				
//------------------------------------------//
bool Texture2DAssetLoader::StartupLoader(std::weak_ptr<class Renderer> renderer)
{
	if (renderer.lock() == nullptr)
	{
		//Fail something
		return false;
	}

	mWeakRenderer = renderer;
	return true;
}
Example #8
0
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 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();
}
Example #10
0
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;
    }
}
Example #11
0
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);
	}
}
Example #12
0
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 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);
	}
Example #14
0
 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]);
 }
Example #15
0
      std::shared_ptr<std::vector<std::string>> check(size_type index,
          string const& message) const
      {
        auto blob_ptr = blob_.lock();
        if (!blob_ptr)
          throw std::runtime_error("unbounded shared_ptr");

        if (index >= blob_ptr->size())
          throw std::out_of_range(message);

        return blob_ptr;
      }
Example #16
0
 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);
 }
		static std::shared_ptr<RawCtx> GetResource(const char * resourceName) {

			rh_rawpak_ctx _ctx = NULL;

			if( rh_rawpak_open_ctx(handle,resourceName, &_ctx) != 0)
				throw LookupException( resourceName );

			std::shared_ptr<RawCtx> ctx =
				std::shared_ptr<RawCtx>(wthis.lock(), _ctx);

			return ctx;
		}
Example #18
0
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;
}
Example #19
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));
    }
  };
}
Example #21
0
	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);
	}
Example #22
0
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();
	}
}
Example #23
0
 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;
 }
Example #24
0
 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);
     }
 }
Example #25
0
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);
            }
        }
    );
}
Example #26
0
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()));
}
Example #27
0
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;
}
Example #28
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;
}
Example #29
0
void LocationsMgr::new_location( Location::ptr nloc , std::weak_ptr<Location> oloc_w )
{
	auto oloc = oloc_w.lock();

	if( oloc )
		nloc->swap_connection( *oloc );

	locations[ nloc->connection ] = nloc;

	nloc->on_location_request(
		std::bind(
			&LocationsMgr::new_location, this,
			std::placeholders::_1 , std::weak_ptr<Location>(nloc) ) );
}
Example #30
0
int DeleteUser(const Data& data, std::weak_ptr<CPlayer> player)
{
    if (!SendCheck(player))
    {
        return -1;
    }
    PBC2SDeleteUserReq req;
    req.ParseFromArray(data.buffer, data.bufferLength);

    PBS2CDeleteUserRes res;
    if (DBServer::GetInstance().DeleteUser(player.lock()->GetPlayerID(), res) != 0)
    {
        return -1;
    }

    player.lock()->GetSocket().lock()->SendBuff((int)TypeS2CDeleteUserRes, res);
    if (res.deleteuserresult() == 1)
    {
        player.lock()->GetSocket().lock()->SetPlayer(std::weak_ptr<CPlayer>());
        PlayerManager::GetInstance().RemovePlayer(player.lock()->GetPlayerID());
    }
    return 0;
}