Exemplo n.º 1
0
 boost::future<autobahn::wamp_authenticate> on_challenge(const autobahn::wamp_challenge& challenge) {
     std::cerr << "responding to auth challenge: " << challenge.challenge() << std::endl;
     std::string signature = compute_wcs(m_secret, challenge.challenge());
     challenge_future.set_value( autobahn::wamp_authenticate(signature) );
     std::cerr << "signature: " << signature << std::endl;
     return challenge_future.get_future();
 };
int main()
{
  {
    boost::future<boost::csbl::unique_ptr<int> > f = p.get_future();
    boost::thread(func).detach();
    BOOST_TEST(*f.get() == 5);
  }
  {
    boost::future<boost::csbl::unique_ptr<int> > f = p2.get_future();
    boost::thread(func2).detach();
    BOOST_TEST(*f.get() == 5);
  }

  return boost::report_errors();
}
Exemplo n.º 3
0
static void ramhog_gen_pad_mt(boost::promise<bool> &done,
                              const uint8_t *input, size_t input_size,
                              uint32_t C, uint32_t padIndex,
                              uint64_t *padOut,
                              bool fForMiner, CBlockIndex *pindexForBest)
{
    if (fForMiner && pindexForBest != pindexBest)
    {
        done.set_value(error("ramhog_gen_pad_mt(): Interrupted from new best block"));
        return;
    }
    
    ramhog_gen_pad(input, input_size, C, padIndex, padOut);
    done.set_value(true);
}
Exemplo n.º 4
0
void accumulate(boost::promise<int> &p)
{
    int sum = 0;
    for (int i = 0; i < 5; ++i)
        sum += i;
    p.set_value(sum);
}
Exemplo n.º 5
0
Arquivo: main.cpp Projeto: CCJY/coliru
void promise_task(boost::promise<std::string> & promise)
{
  std::cout << "promise_task" << std::endl;
//  sleep (2);
  promise.set_value("PROMISE");

}
Exemplo n.º 6
0
	channel_consumer()
		: consumer_index_(next_consumer_index())
		, first_frame_available_(first_frame_promise_.get_future())
		, first_frame_reported_(false)
	{
		is_running_ = true;
		current_age_ = 0;
		frame_buffer_.set_capacity(3);
	}
Exemplo n.º 7
0
void wait_callback(boost::promise<int>& pi)
{
    boost::lock_guard<boost::mutex> lk(callback_mutex);
    ++callback_called;
    try
    {
        pi.set_value(42);
    }
    catch(...)
    {
    }
}
int main()
{
  {
    //boost::promise<int&> p;
    boost::future<int&> f = p.get_future();
    //boost::thread(func, boost::move(p)).detach();
    boost::thread(func).detach();
    int r = f.get();
    BOOST_TEST(r == 4);
  }
  return boost::report_errors();
}
Exemplo n.º 9
0
	virtual boost::unique_future<bool> send(const safe_ptr<read_frame>& frame) override
	{
		bool pushed = frame_buffer_.try_push(frame);

		if (pushed && !first_frame_reported_)
		{
			first_frame_promise_.set_value();
			first_frame_reported_ = true;
		}

		return caspar::wrap_as_future(is_running_.load());
	}
Exemplo n.º 10
0
	virtual void send(const safe_ptr<basic_frame>& src_frame) override
	{
		bool pushed = frame_buffer_.try_push(src_frame);
//		frame_buffer_.push(src_frame);

		if (pushed && !first_frame_reported_) //changed to fix compilation
		//if (!first_frame_reported_)
		{
			first_frame_promise_.set_value();
			first_frame_reported_ = true;
		}
	}
Exemplo n.º 11
0
 WorkItem(const Request& req,
          ExtraSendFun* send_extra,
          ExtraRecvFun* recv_extra)
     : request(req)
     , request_tag(allocate_tag())
     , request_type(vfsprotocol::RequestTraits<Request>::request_type)
     , request_desc(vfsprotocol::request_type_to_string(request_type))
     , send_extra_fun(send_extra)
     , recv_extra_fun(recv_extra)
       // clang++ (3.8.0-2ubuntu3~trusty4) complains otherwise about
       // 'promise' being used unitialized when initializing 'future'
     , promise()
     , future(promise.get_future())
 {}
int main()
{
  {
    typedef int T;
    //boost::promise<T> p;
    boost::future<T> f = p.get_future();
    //boost::thread(func, boost::move(p)).detach();
    boost::thread(func).detach();
    try
    {
      f.get();
      BOOST_TEST(false);
    }
    catch (boost::wrap<int> i)
    {
      BOOST_TEST(i.value == 3);
    }
    catch (...)
    {
      BOOST_TEST(false);
    }
  }
  {
    typedef int T;
    boost::promise<T> p2;
    boost::future<T> f = p2.get_future();
    //boost::thread(func, boost::move(p)).detach();
    p = boost::move(p2);
    boost::thread(func).detach();
    try
    {
      f.get();
      BOOST_TEST(false);
    }
    catch (boost::wrap<int> i)
    {
      BOOST_TEST(i.value == 3);
    }
    catch (...)
    {
      BOOST_TEST(false);
    }
  }
  return boost::report_errors();
}
Exemplo n.º 13
0
void func1(boost::promise<int> p)
{
  boost::this_thread::sleep_for(ms(500));
  p.set_value(3);
}
int main()
{
  {
    //boost::promise<boost::interprocess::unique_ptr<int, boost::default_delete<int>> > p;
    boost::future<boost::interprocess::unique_ptr<int, boost::default_delete<int> > > f = p.get_future();
    //boost::thread(func, boost::move(p)).detach();
    boost::thread(func).detach();
    BOOST_TEST(*f.get() == 5);
  }

  return boost::report_errors();
}
void func()
{
  p.set_exception_at_thread_exit(boost::make_exception_ptr(3));
}
Exemplo n.º 16
0
 RunCommand(const mongo::BSONObj& cmd, mongo::BSONObj& ret, 
   boost::unique_future<bool>& future) : cmd(cmd), ret(ret), future(future)
 {
   future = promise.get_future();
 }
void func()
{
  boost::interprocess::unique_ptr<int, boost::default_delete<int> > uptr(new int(5));
  p.set_value_at_thread_exit(boost::move(uptr));
}
Exemplo n.º 18
0
void func6(boost::promise<void> p)
{
    boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
    p.set_exception(boost::make_exception_ptr('c'));
}
Exemplo n.º 19
0
 Select(const std::string& container, const mongo::Query& query,
   QueryResults& results, boost::unique_future<bool>& future, int limit = 0) : 
     container(container), query(query), results(results), future(future),
     promise(), limit(limit) { future = promise.get_future(); }
Exemplo n.º 20
0
void func4(boost::promise<int&> p)
{
    boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
    p.set_exception(boost::make_exception_ptr(3.5));
}
Exemplo n.º 21
0
void func5(boost::promise<void> p)
{
    boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
    p.set_value();
}
void func()
{
  p.set_value_at_thread_exit(i);
  i = 4;
}
Exemplo n.º 23
0
void func3(boost::promise<int&> p)
{
    boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
    j = 5;
    p.set_value(j);
}
Exemplo n.º 24
0
void func5(boost::promise<void> p)
{
  boost::this_thread::sleep_for(ms(500));
  p.set_value();
}
Exemplo n.º 25
0
void func3(boost::promise<int&> p)
{
  boost::this_thread::sleep_for(ms(500));
  j = 5;
  p.set_value(j);
}
void func()
{
  boost::csbl::unique_ptr<int> uptr(new int(5));
  p.set_value_at_thread_exit(boost::move(uptr));
}
void func2()
{
  p2.set_value_at_thread_exit(boost::csbl::make_unique<int>(5));
}
Exemplo n.º 28
0
	layer_consumer() : first_frame_reported_(false)
	{
		first_frame_available_ = first_frame_promise_.get_future();
		frame_buffer_.set_capacity(2);
	}