C++ Channel::Read方法代码示例

HRESULT __stdcall DpReadChannelData(CHANNEL_HANDLE handle, char * buf, int lenBuf, int * pLenRead)
{
	Lock(&viewerMain.spinLockChannelTable);
	Channel * channel = (Channel *)viewerMain.channelHandleTable.Get((int)handle);
	Unlock(&viewerMain.spinLockChannelTable);

	if (channel == 0)
	{
		if (pLenRead != 0)
			*pLenRead = 0;
		return E_INVALID_CHANNEL_HANDLE;
	}

	int lenRead = channel->Read(buf, lenBuf);

	if (pLenRead != 0)
		*pLenRead = lenRead;

	if (lenRead < lenBuf)
	{
		if (!channel->IsWriterAlive())
			return E_CHANNEL_CLOSED;
	}

	return S_OK;
}

/**
 * FrameProxy::MessageHandlerListener
 */
DWORD FrameProxy::MessageHandlerListener(LPVOID param)
{
    logger->debug(L"FrameProxy::MessageHandlerListener" 
                  L" -> " + boost::lexical_cast<wstring>(param));

    Channel *channel = (Channel*)param;
    char     buffer[Channel::SECTION_SIZE];

    while (channel->Read(buffer, Channel::SECTION_SIZE)) {
        
        UINTX type = *(UINTX*)buffer;
        logger->debug(L"FrameProxy::MessageHandlerListener type" 
                      L" -> " + boost::lexical_cast<wstring>(type));
        
        switch(type) {
        case ForwardedMessage::COMMAND_TYPE: {
            logger->debug(L"FrameProxy::MessageHandlerListener ForwardedMessage");
            ForwardedMessage *message = (ForwardedMessage*)buffer;
            FrameProxy       *proxy   = (FrameProxy*)message->proxy;
            LRESULT result;
            proxy->WndProcTarget(&result, 
                                 message->msg, 
                                 message->wparam, 
                                 message->lparam);

        }
            break;

        case button_onClickCommand::COMMAND_TYPE: {
            logger->debug(L"FrameProxy::MessageHandlerListener button_onClickCommand");
            button_onClickCommand *command = (button_onClickCommand*)buffer;
            command->exec();
        }
            break;
                        
        default:
            logger->debug(L"FrameProxy::MessageHandlerListener unknown type"
                          L" -> " + boost::lexical_cast<wstring>(type));
            ForwardedMessage *message = (ForwardedMessage*)buffer;
            FrameProxy       *proxy   = (FrameProxy*)message->proxy;
            LRESULT result;
            proxy->WndProcTarget(&result, 
                                 message->msg, 
                                 message->wparam, 
                                 message->lparam);

            break;
        }
    }
    
    return 0;
}

void fibonacci(std::uint16_t n, Channel < std::pair<std::uint16_t, std::uint64_t> > chan, Channel<int> stopchan){
	// First fibonacci is 0
	// So go ahead and write that as our first value
	auto fut = chan.Write({ 0, 0 });

	auto stopfut = stopchan.Read();

	// A vector to hold our intermediate calculations
	std::vector<std::uint64_t> fibs(n+1);

	
	if (n == 0){
		return;
	}
	if (n == 1){
		chan.Write({ 1, 1 });
		return;
	}

	// Set the 0th and 1st fibonacci numbers
	fibs[0] = 0;
	fibs[1] = 1;

	// Calculate all the fibonacci numbers up to and including n
	for (std::uint16_t i = 2; i <= n; ++i){
		// Fibonacci forumula
		fibs[i] = fibs[i - 2] + fibs[i - 1];

		// fut (the Future from chan.Write, will become ready when somebody reads the channel
		// that is a trigger that we need to write the latest value to the channel
		// Also, if we are done calculating (i==n) we write the value to the channel
		if (fut.Ready() || i==n || stopfut.Ready()){
			fut = chan.Write({ i, fibs[i] });

			// Check if we were called to stop
			if (stopfut.Ready()){
				return;
			}
		}
		
		
		// Slow us down so it looks like a long calculation, otherwise it runs too fast
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
	}

	

}

void tcp_echo_server(int port, Channel<int> stopchan, use<ITty> out, awaiter await){

	// stopfut will become ready when someone writes to the channel
	auto stopfut = stopchan.Read();

	// Set up our Tcp Server at the specified port
	TcpStream server;
	auto server_addr = Uv::Ip4Addr("0.0.0.0", port);
	server.Bind(server_addr);



	// We use this to tell the client connections they should stop
	auto stopclientchan = make_channel<int>();

	// Start listening
	server.Listen(1, resumable([stopclientchan](use<IUvStream> is, int, awaiter await){	// This is the function that handles the client
		auto stopfut = stopclientchan.Read();

		TcpStream client;
		is.Accept(client);

		// Get the read channel
		auto readchan = client.ReadStartWithChannel();

		// Loop and read the channel, as long as
		while ( !stopfut.Ready()){
		

			// Get the readfuture from the channel
			auto readfut = readchan.Read();

			// Wait for either some data available to read, or else we were told to stop
			await(when_any(readfut,stopfut));

			// Check that the read future is the cause as opposed to being told to stop
			if (readfut.Ready()){
				// Get the buffer
				auto buf = readfut.Get();

				// Generate the http response
				// In this case we are echoing back using http
				std::stringstream strstream;
				strstream <<
					"HTTP/1.1 200 OK\r\n"
					"Content-Type: text/plain\r\n"
					"Content-Length: " << buf.Size() << "\r\n"
					"\r\n";

				strstream.write(buf.Begin(), buf.Size());
				strstream << "\r\n\r\n";

				// Write to the client
				await(client.Write(strstream.str()));
			}

		}
	}));
	// as opposed to await.operator(), await.as_future returns the future
	// This is useful if you don't want to throw an exception on an error in the future
	await.as_future(stopfut);

	// This will close out all the attempted reads on the channel with an error
	stopclientchan.Complete();
}