C++ Response类代码示例

//External Includes
#include <catch.hpp>

//System Namespaces
using std::string;
using std::multimap;

//Project Namespaces
using restbed::Response;

//External Namespaces

TEST_CASE( "validate default instance values", "[response]" )
{
    const Response response;
    
    REQUIRE( response.get_version( ) == 1.1 );
    REQUIRE( response.get_status_code( ) == 200 );
    REQUIRE( response.get_protocol( ) == "HTTP" );
    REQUIRE( response.get_headers( ).empty( ) );
    REQUIRE( response.get_status_message( ).empty( ) );
    REQUIRE( response.get_request( ) == nullptr );
}

TEST_CASE( "confirm default destructor throws no exceptions", "[response]" )
{
    auto response = new Response;
    
    REQUIRE_NOTHROW( delete response );
}

int main(int argc, char* argv[])
{
  int ret = 1;
  try {

    memPool.reserve(1 << 20);

    unique_ptr<Journ> journ;
    unique_ptr<Model> model;
    if (argc > 1) {
      Conf conf;
      conf.set("sqlite_journ", argv[1]);
      conf.set("sqlite_model", argv[1]);
      journ = swirly::makeJourn(conf);
      model = swirly::makeModel(conf);
    } else {
      journ = make_unique<TestJourn>();
      model = make_unique<TestModel>();
    }

    const BusinessDay busDay{RollHour, NewYork};
    const auto now = UnixClock::now();

    Serv serv{*journ, 1 << 10, 1 << 4};
    serv.load(*model, now);
    model = nullptr;

    auto& market = createMarket(serv, "EURUSD"_sv, busDay(now), 0, now);

    auto& eddayl = serv.accnt("EDDAYL"_sv);
    auto& gosayl = serv.accnt("GOSAYL"_sv);
    auto& marayl = serv.accnt("MARAYL"_sv);
    auto& pipayl = serv.accnt("PIPAYL"_sv);

    Profile maker{"maker"_sv};
    Profile taker{"taker"_sv};

    Archiver arch{serv};
    Response resp;
    for (int i = 0; i < 25100; ++i) {

      // Reset profiles after warmup period.
      if (i == 100) {
        maker.clear();
        taker.clear();
      }

      // Maker sell-side.
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(gosayl, market, ""_sv, Side::Sell, 10_lts, 12348_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(marayl, market, ""_sv, Side::Sell, 10_lts, 12348_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(gosayl, market, ""_sv, Side::Sell, 10_lts, 12347_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(marayl, market, ""_sv, Side::Sell, 5_lts, 12347_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(gosayl, market, ""_sv, Side::Sell, 5_lts, 12346_tks, 1_lts, now, resp);
      }

      // Maker buy-side.
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(marayl, market, ""_sv, Side::Buy, 5_lts, 12344_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(gosayl, market, ""_sv, Side::Buy, 5_lts, 12343_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(marayl, market, ""_sv, Side::Buy, 10_lts, 12343_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(gosayl, market, ""_sv, Side::Buy, 10_lts, 12342_tks, 1_lts, now, resp);
      }
      {
        TimeRecorder tr{maker};
        resp.clear();
        serv.createOrder(marayl, market, ""_sv, Side::Buy, 10_lts, 12342_tks, 1_lts, now, resp);
      }
//.........这里部分代码省略.........

Response kConnection::receive_response() {
	Response r;
	auto s = readmessage();
	r.ParseFromString(s);
	return r;
}

void TabMessage::messageSent(const Response &response)
{
    if (response.response_code() == Response::RespInIgnoreList)
        chatView->appendMessage(tr("This user is ignoring you."));
}

bool LayoutEditor::setCSSPropertyValueInCurrentRule(const String& value) {
  Response response = m_cssAgent->setLayoutEditorValue(
      m_element.get(), m_matchedStyles.at(m_currentRuleIndex),
      m_changingProperty, value, false);
  return response.isSuccess();
}

void
grandet_fetch_task_wait(grandet_fetch_task_t task) {
    task->lock.lock();
    if (task->finished == 0 && task->canceled == 0) {
        INFO("grandet_fetch_task processing\n");

        Request req;
        req.set_type(Request::GET);
        req.set_key(task->key);
        Request::Requirements *reqm = req.mutable_requirements();
        reqm->set_latency_required(_latency_requirement);
        reqm->set_bandwidth_required(_bandwidth_requirement);

        tcp::iostream *conn;
        conn_get(conn);
        if (!_write_message(*conn, req)) {
            DEBUG("grandet_fetch_task failed to write\n");
            task->canceled = 1;
            task->finished = 1;
            conn_put(conn);
            task->lock.unlock();
            return;
        }
        Response reply;
        if (!_read_message(*conn, reply)) {
            DEBUG("grandet_fetch_task failed to read response\n");
            task->canceled = 1;
            task->finished = 1;
            conn_put(conn);
            task->lock.unlock();
            return;
        }
        conn_put(conn);

        if (reply.status() != Response::OK) {
            DEBUG("grandet_fetch_task failed\n");
            task->canceled = 1;
        } else {
            ostringstream o;
            o << task->data_path << "_XXXXXX";
            char *tmp_path = strdup(o.str().c_str());
            int tmp_fh = mkstemp(tmp_path);

            const Value &val = reply.value();
            if (val.has_data()) {
                const string &data = val.data();
                INFO("grandet_fetch_task fetch data length %d\n", data.length());
                const char *buf = data.c_str();
                int length = data.length();
                if (length > task->size) length = task->size;
                while (length > 0) {
                    int w = write(tmp_fh, buf, length);
                    if (w < 0) {
                        DEBUG("grandet_fetch_task write failed\n");
                        task->canceled = 1;
                        break;
                    }
                    length -= w;
                    buf    += w;
                }
                ftruncate(tmp_fh, task->size);
            }

            close(tmp_fh);

            if (!task->canceled) {
                int r = rename(tmp_path, task->data_path);
                INFO("rename %s to %s ret %d\n", task->tmp_path, task->data_path, r == -1 ? errno : r);
            } else {
                unlink(tmp_path);
            }
        }

        task->finished = 1;
    }
    task->lock.unlock();
}

int main(int argc, char **argv)
{
	if (argc < 2) {
		fprintf(stderr, "Usage: %s ADDRESS...\n", argv[0]);
		return 2;
	}

	const char *progname = strrchr(argv[0], '/');
	if (progname)
		progname++;
	else
		progname = argv[0];

	openlog(progname, LOG_CONS | LOG_NDELAY | LOG_PID, LOG_USER);

	magic_cookie = magic_open(MAGIC_MIME_TYPE);
	if (magic_load(magic_cookie, nullptr) < 0) {
		syslog(LOG_CRIT, "magic: %s", strerror(errno));
		return 1;
	}

	Magick::InitializeMagick(argv[0]);

	zmq::context_t context(1);
	zmq::socket_t socket(context, ZMQ_REP);

	try {
		for (int i = 1; i < argc; i++)
			socket.bind(argv[i]);

		while (true) {
			IO io(socket);

			if (!io.receive()) {
				syslog(LOG_ERR, "request message was too short");
				continue;
			}

			Request request;
			Response response;

			if (!decode_request(io.request.first, request)) {
				syslog(LOG_ERR, "could not decode request header");
				continue;
			}

			const char *mimetype = magic_buffer(magic_cookie, io.request.second.data(), io.request.second.size());

			response.set_source_type(mimetype);

			if (mimetype && (strcmp(mimetype, "image/bmp") == 0 ||
			                 strcmp(mimetype, "image/gif") == 0 ||
			                 strcmp(mimetype, "image/jpeg") == 0 ||
			                 strcmp(mimetype, "image/png") == 0)) {
				try {
					Magick::Blob blob(io.request.second.data(), io.request.second.size());
					Magick::Image image(blob);

					convert_image(image, request.scale(), request.crop());
					response.set_nail_width(image.size().width());
					response.set_nail_height(image.size().height());
					write_jpeg(image, io.response.second);
				} catch (const Magick::Exception &e) {
					syslog(LOG_ERR, "magick: %s", e.what());
					continue;
				}
			}

			encode_response(response, io.response.first);
			io.handled = true;
		}
	} catch (const zmq::error_t &e) {
		syslog(LOG_CRIT, "zmq: %s", e.what());
	}

	return 1;
}

bool FTPClient::processRequest(char* input)
{
    Request r;
    int ret_val = r.parseTerminalCommand(input);
    if (ret_val == 2)
        return false;

    if(r.getCommand () == PWD)
    {
       controlSocket.send (r.getRequestString ());
       string recv_str = controlSocket.recv (RECV_SIZE);
       Response res = Response::parseResponse (recv_str);
       cout << recv_str;
    }
    else if (r.getCommand () == CWD)
    {
        controlSocket.send (r.getRequestString ());
        string recv_str = controlSocket.recv (RECV_SIZE);
        Response res = Response::parseResponse (recv_str);
        cout << recv_str;
    }
    else if (r.getCommand () == LIST)
    {
        Socket datSock;
        if (!establishPORT (datSock))
        {
            cerr << "ERROR: Data connection failed." << endl;
            return false;
        }
        controlSocket.send (r.getRequestString ());
        string recv_str = controlSocket.recv (RECV_SIZE);
        cout << recv_str << "\n";
        while ((recv_str = datSock.recv (RECV_SIZE)).length () > 0)
        {
            cout << recv_str;
        }
        datSock.close ();
        recv_str = controlSocket.recv (RECV_SIZE);
        cout << "\n" << recv_str;
    }
    else if (r.getCommand () == RETR)
    {
        Socket datSock;
        if (!establishPORT (datSock))
        {
            cerr << "ERROR: Data connection failed." << endl;
            return false;
        }
        controlSocket.send (r.getRequestString ());
        string recv_str = controlSocket.recv (RECV_SIZE);
        Response res = Response::parseResponse (recv_str);
        if (res.getReturnCode () == FILE_NOT_FOUND)
        {
            cout << recv_str;
            datSock.close ();
            return false;
        }
        cout << recv_str;
        ofstream out_file;
        out_file.open (r.getArg ().c_str (), ios::out);
        if (!out_file.is_open ())
        {
            cerr << "ERROR! Could not open file." << endl;
            datSock.close ();
            return false;
        }
        char recv_str_data[RECV_SIZE];
        int recv_len;
        while ((recv_len = datSock.recv (recv_str_data, RECV_SIZE)) > 0)
        {
            out_file.write (recv_str_data, recv_len);
        }
        datSock.close ();
        out_file.close ();
        recv_str = controlSocket.recv (RECV_SIZE);
        cout << recv_str;
    }
    else if (r.getCommand () == STOR)
    {
        Socket datSock;
        if (!establishPORT (datSock))
        {
            cerr << "ERROR! Data connection failed." << endl;
            return false;
        }
        controlSocket.send (r.getRequestString ());
        string recv_str = controlSocket.recv (RECV_SIZE);
        Response res = Response::parseResponse (recv_str);
        if (res.getReturnCode () == FILE_NOT_FOUND)
        {
            cout << recv_str;
            datSock.close ();
            return false;
        }
        cout << recv_str;
        ifstream in_file;
        string args = r.getArg ();
        in_file.open (args.c_str (), ios::in | ios::ate);
        if (!in_file.is_open ())
        {
//.........这里部分代码省略.........

// check if limit state surface has been reached
int
ShearCurve::checkElementState(double springForce)
{
  DummyStream dummy;
	// find associated beam-column elementon first visit
	if (theElement == 0)
	{
		theElement = theDomain->getElement(eleTag);

		if (theElement == 0) {
//			g3ErrorHandler->fatal("WARNING ShearCurve - no element with tag %i exists in Domain",eleTag);
		}
		// find length between nodes if drift is desired
		if (defType == 2)
		{
			Node *nodeI = theDomain->getNode(ndI);
			Node *nodeJ = theDomain->getNode(ndJ);

			const Vector &crdI = nodeI->getCrds();
			const Vector &crdJ = nodeJ->getCrds();

			if (crdI(perpDirn) == crdJ(perpDirn)) {
//				g3ErrorHandler->warning("%s -- Nodal projection has zero component along chosen direction",
//						"AxialCurve::AxialCurve");

				oneOverL = 0.0;
			}
			else 
				oneOverL = 1.0/fabs(crdJ(perpDirn) - crdI(perpDirn));
		}
	}

	double deform;	// value of deformation parameter from element
	double force;	// value of force parameter from element
	int result;		//junk variable


	// Based on "defType" and "forType" calculate 
	// the desired response parameters "deform" and "force"
	if (defType == 1) // maximum chord rotations
	{

		Response *theRotations =0; // integer element returns in setResponse

		const char *r[1] = {"basicDeformations"}; // must be implemented in element

		Vector *rotVec; //vector of chord rotations at beam-column ends

		// set type of beam-column element response desired
		theRotations = theElement->setResponse(r, 1, dummy);

		// put element response in the vector of "myInfo"
		result = theRotations->getResponse();

		// access the myInfo vector containing the response (new for Version 1.2)
		Information &theInfo = theRotations->getInformation();
		rotVec = (theInfo.theVector);

		deform = (fabs((*rotVec)(1)) > fabs((*rotVec)(2))) ? 
			fabs((*rotVec)(1)) : fabs((*rotVec)(2));  //use larger of two end rotations
	}
	else if (defType == 2) // interstory drift
	{
		// find associated nodes 
		Node *nodeI = theDomain->getNode(ndI);
		Node *nodeJ = theDomain->getNode(ndJ);


		// get displacements
		const Vector &dispI = nodeI->getTrialDisp();
		const Vector &dispJ = nodeJ->getTrialDisp();

//opserr << "Drift ndI: " << dispI(dof) << endln;
//opserr << "Drift ndJ: " << dispJ(dof) << endln;

		
		// calc drift
		double dx = fabs(dispJ(dof)-dispI(dof));
		deform = dx*oneOverL;
	}
	else {
//		g3ErrorHandler->fatal("WARNING ShearCurve - deformation type flag %i not implemented",defType);
	}

		Response *theForces =0;

		const char *f[1] = {"localForce"}; // does not include influence of P-delta
								     // for P-delta use forType = 0

		Vector *forceVec; //vector of basic forces from beam column

		// set type of beam-column element response desired
		theForces    = theElement->setResponse(f, 1, dummy);

		// put element response in the vector of "myInfo"
		result += theForces->getResponse();

		// access the myInfo vector containing the response (new for Version 1.2)
		Information &theInfo = theForces->getInformation();
//.........这里部分代码省略.........

	//---------------------------------------------------------------------
	void DefaultWorkQueueBase::processRequestResponse(Request* r, bool synchronous)
	{
		Response* response = processRequest(r);

		OGRE_LOCK_MUTEX(mProcessMutex);

		RequestQueue::iterator it;
		for( it = mProcessQueue.begin(); it != mProcessQueue.end(); ++it )
		{
			if( (*it) == r )
			{
				mProcessQueue.erase( it );
				break;
			}
		}
		if( mIdleProcessed == r )
		{
			mIdleProcessed = 0;
		}
		if (response)
		{
			if (!response->succeeded())
			{
				// Failed, should we retry?
				const Request* req = response->getRequest();
				if (req->getRetryCount())
				{
					addRequestWithRID(req->getID(), req->getChannel(), req->getType(), req->getData(), 
						req->getRetryCount() - 1);
					// discard response (this also deletes request)
					OGRE_DELETE response;
					return;
				}
			}
			if (synchronous)
			{
				processResponse(response);
				OGRE_DELETE response;
			}
			else
			{
				if( response->getRequest()->getAborted() )
				{
					// destroy response user data
					response->abortRequest();
				}
				// Queue response
				OGRE_LOCK_MUTEX(mResponseMutex);
				mResponseQueue.push_back(response);
				// no need to wake thread, this is processed by the main thread
			}

		}
		else
		{
			if (!r->getAborted())
			{
			// no response, delete request
			LogManager::getSingleton().stream() << 
				"DefaultWorkQueueBase('" << mName << "') warning: no handler processed request "
				<< r->getID() << ", channel " << r->getChannel()
				<< ", type " << r->getType();
			}
			OGRE_DELETE r;
		}

	}

 void execute(const Request&, Response& response) {
     response.set_frame_size(1520);
     response.set_link_technology("Ethernet");
     response.set_speed_gbps(1);
     response.set_autosense(true);
     response.set_mac_address("AA:BB:CC:DD:EE:FF");
     response.set_ipv4_address({"10.0.2.2",
                                "255.255.255.0",
                                "DHCP",
                                "10.0.2.1"});
     response.set_ipv6_address({"fe80::1ec1:deff:fe6f:1c37",
                                16,
                                "DHCP",
                                "Perferred"});
     response.set_neighbor_info({"123e4567-e89b-12d3-a456-426655440000",
                                 "19"});
     response.set_vlan_enable(true);
     response.set_vlan_count(1);
     response.set_status({"Enabled", "OK"});
 }

#include <corvusoft/restbed/byte.hpp>
#include <corvusoft/restbed/response.hpp>

//External Includes
#include <catch.hpp>

//System Namespaces

//Project Namespaces
using restbed::Bytes;
using restbed::Response;

//External Namespaces

TEST_CASE( "validate default instance values", "[response]" )
{
    const Response response;
    REQUIRE( response.get_body( ).empty( ) );
}

TEST_CASE( "validate setters modify default values", "[response]" )
{
    Bytes expectation = { 'a', 'b' };
    
    Response response;
    response.set_body( expectation );
    
    const auto body = response.get_body( );
    REQUIRE( body == expectation );
}