mirror of https://github.com/davisking/dlib.git
366 lines
12 KiB
C++
366 lines
12 KiB
C++
// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
|
|
|
|
|
|
/*
|
|
This is an example showing how to use the bridge object from from the
|
|
dlib C++ Library to send messages via TCP/IP.
|
|
|
|
In particular, this example will walk you through four progressively
|
|
more complex use cases of the bridge object. Note that this example
|
|
program assumes you are already familiar with the pipe object and at
|
|
least the contents of the pipe_ex_2.cpp example program.
|
|
*/
|
|
|
|
|
|
// =========== Example program output ===========
|
|
/*
|
|
---- Running example 1 ----
|
|
dequeued value: 1
|
|
dequeued value: 2
|
|
dequeued value: 3
|
|
|
|
---- Running example 2 ----
|
|
dequeued value: 1
|
|
dequeued value: 2
|
|
dequeued value: 3
|
|
|
|
---- Running example 3 ----
|
|
dequeued int: 1
|
|
dequeued int: 2
|
|
dequeued struct: 3 some string
|
|
|
|
---- Running example 4 ----
|
|
bridge 1 status: is_connected: true
|
|
bridge 1 status: foreign_ip: 127.0.0.1
|
|
bridge 1 status: foreign_port: 43156
|
|
bridge 2 status: is_connected: true
|
|
bridge 2 status: foreign_ip: 127.0.0.1
|
|
bridge 2 status: foreign_port: 12345
|
|
dequeued int: 1
|
|
dequeued int: 2
|
|
dequeued struct: 3 some string
|
|
bridge 1 status: is_connected: false
|
|
bridge 1 status: foreign_ip: 127.0.0.1
|
|
bridge 1 status: foreign_port: 12345
|
|
*/
|
|
|
|
|
|
#include <dlib/bridge.h>
|
|
#include <dlib/type_safe_union.h>
|
|
#include <iostream>
|
|
|
|
using namespace dlib;
|
|
using namespace std;
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
void run_example_1();
|
|
void run_example_2();
|
|
void run_example_3();
|
|
void run_example_4();
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
int main()
|
|
{
|
|
run_example_1();
|
|
run_example_2();
|
|
run_example_3();
|
|
run_example_4();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
void run_example_1(
|
|
)
|
|
{
|
|
cout << "\n ---- Running example 1 ---- " << endl;
|
|
|
|
/*
|
|
The idea of the bridge is basically to allow two different dlib::pipe objects
|
|
to be connected together via a TCP connection. This is best illustrated by
|
|
the following short example. In it we create two pipes, in and out. When
|
|
an object is enqueued into the out pipe it will be automatically sent
|
|
through a TCP connection and once received at the other end it will be
|
|
inserted into the in pipe.
|
|
*/
|
|
dlib::pipe<int> in(4), out(4);
|
|
|
|
|
|
// This bridge will listen on port 12345 for an incoming TCP connection. Then
|
|
// it will read data from that connection and put it into the in pipe.
|
|
bridge b2(listen_on_port(12345), receive(in));
|
|
|
|
// This bridge will initiate a TCP connection and then start dequeuing
|
|
// objects from out and transmitting them over the connection.
|
|
bridge b1(connect_to_ip_and_port("127.0.0.1", 12345), transmit(out));
|
|
|
|
// As an aside, in a real program, each of these bridges and pipes would be in a
|
|
// separate application. But to make this example self contained they are both
|
|
// right here.
|
|
|
|
|
|
|
|
// Now let's put some things into the out pipe
|
|
int value = 1;
|
|
out.enqueue(value);
|
|
|
|
value = 2;
|
|
out.enqueue(value);
|
|
|
|
value = 3;
|
|
out.enqueue(value);
|
|
|
|
|
|
// Now those 3 ints can be dequeued from the in pipe. They will show up
|
|
// in the same order they were inserted into the out pipe.
|
|
in.dequeue(value);
|
|
cout << "dequeued value: "<< value << endl;
|
|
in.dequeue(value);
|
|
cout << "dequeued value: "<< value << endl;
|
|
in.dequeue(value);
|
|
cout << "dequeued value: "<< value << endl;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
void run_example_2(
|
|
)
|
|
{
|
|
cout << "\n ---- Running example 2 ---- " << endl;
|
|
|
|
/*
|
|
This example makes a simple echo server on port 12345. When an object
|
|
is inserted into the out pipe it will be sent over a TCP connection, get
|
|
put into the echo pipe and then immediately read out of the echo pipe and
|
|
sent back over the TCP connection where it will finally be placed into the in
|
|
pipe.
|
|
*/
|
|
|
|
dlib::pipe<int> in(4), out(4), echo(4);
|
|
|
|
// Just like TCP connections, a bridge can send data both directions. The directionality
|
|
// of a pipe is indicated by the receive() and transmit() type decorations. Also, the order
|
|
// they are listed doesn't matter.
|
|
bridge echo_bridge(listen_on_port(12345), receive(echo), transmit(echo));
|
|
|
|
// Note that you can also specify the ip and port as a string by using connect_to().
|
|
bridge b1(connect_to("127.0.0.1:12345"), transmit(out), receive(in));
|
|
|
|
|
|
int value = 1;
|
|
out.enqueue(value);
|
|
|
|
value = 2;
|
|
out.enqueue(value);
|
|
|
|
value = 3;
|
|
out.enqueue(value);
|
|
|
|
|
|
in.dequeue(value);
|
|
cout << "dequeued value: "<< value << endl;
|
|
in.dequeue(value);
|
|
cout << "dequeued value: "<< value << endl;
|
|
in.dequeue(value);
|
|
cout << "dequeued value: "<< value << endl;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
struct my_example_object
|
|
{
|
|
/*
|
|
All objects passing through a dlib::bridge must be serializable. This
|
|
means there must exist global functions called serialize() and deserialize()
|
|
which can convert an object into a bit stream and then reverse the process.
|
|
|
|
This example object illustrates how this is done.
|
|
*/
|
|
|
|
int value;
|
|
std::string str;
|
|
};
|
|
|
|
void serialize (const my_example_object& item, std::ostream& out)
|
|
{
|
|
/*
|
|
serialize() just needs to write the state of item to the output stream.
|
|
You can do this however you like. Below, I'm using the serialize functions
|
|
for int and std::string which come with dlib. But again, you can do whatever
|
|
you want here.
|
|
*/
|
|
dlib::serialize(item.value, out);
|
|
dlib::serialize(item.str, out);
|
|
}
|
|
|
|
void deserialize (my_example_object& item, std::istream& in)
|
|
{
|
|
/*
|
|
deserialize() is just the inverse of serialize(). Again, you can do
|
|
whatever you want here so long as it correctly reconstructs item. This
|
|
also means that deserialize() must always consume as many bytes as serialize()
|
|
generates.
|
|
*/
|
|
dlib::deserialize(item.value, in);
|
|
dlib::deserialize(item.str, in);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
void run_example_3(
|
|
)
|
|
{
|
|
cout << "\n ---- Running example 3 ---- " << endl;
|
|
|
|
/*
|
|
In this example we will just send ints and my_example_object objects
|
|
over a TCP connection. Since we are sending more than one type of
|
|
object through a pipe we will need to use the type_safe_union.
|
|
*/
|
|
|
|
typedef type_safe_union<int, my_example_object> tsu_type;
|
|
|
|
dlib::pipe<tsu_type> in(4), out(4);
|
|
|
|
// Note that we don't have to start the listening bridge first. If b2
|
|
// fails to make a connection it will just keep trying until successful.
|
|
bridge b2(connect_to("127.0.0.1:12345"), receive(in));
|
|
// We don't have to configure a bridge in it's constructor. If it's
|
|
// more convenient we can do so by calling reconfigure() instead.
|
|
bridge b1;
|
|
b1.reconfigure(listen_on_port(12345), transmit(out));
|
|
|
|
tsu_type msg;
|
|
|
|
msg = 1;
|
|
out.enqueue(msg);
|
|
|
|
msg = 2;
|
|
out.enqueue(msg);
|
|
|
|
msg.get<my_example_object>().value = 3;
|
|
msg.get<my_example_object>().str = "some string";
|
|
out.enqueue(msg);
|
|
|
|
|
|
// dequeue the three objects we sent and print them on the screen.
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
in.dequeue(msg);
|
|
if (msg.contains<int>())
|
|
{
|
|
cout << "dequeued int: "<< msg.get<int>() << endl;
|
|
}
|
|
else if (msg.contains<my_example_object>())
|
|
{
|
|
cout << "dequeued struct: "<< msg.get<my_example_object>().value << " "
|
|
<< msg.get<my_example_object>().str << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
void run_example_4(
|
|
)
|
|
{
|
|
cout << "\n ---- Running example 4 ---- " << endl;
|
|
|
|
/*
|
|
This final example is the same as example 3 except we will also now be getting
|
|
status messages from the bridges. These bridge_status messages tell us the
|
|
state of the TCP connection associated with a bridge. Is it connected or not?
|
|
Who it is connected to?
|
|
|
|
The way you get these status messages is by ensuring that your receive pipe is
|
|
capable of storing bridge_status objects. If it is then the bridge will
|
|
automatically insert bridge_status messages into your receive pipe whenever
|
|
there is a status change.
|
|
|
|
There are only two kinds of status changes. The establishment of a connection
|
|
or the closing of a connection. Also, a connection which closes due to you
|
|
calling clear(), reconfigure(), or destructing a bridge does not generate a
|
|
status message since, in this case, you already know about it and just want
|
|
the bridge to destroy itself as quickly as possible.
|
|
*/
|
|
|
|
|
|
typedef type_safe_union<int, my_example_object, bridge_status> tsu_type;
|
|
|
|
dlib::pipe<tsu_type> in(4), out(4);
|
|
dlib::pipe<bridge_status> b1_status(4);
|
|
|
|
// setup both bridges to have receive pipes capable of holding bridge_status messages.
|
|
bridge b1(listen_on_port(12345), transmit(out), receive(b1_status));
|
|
// Note that we can also use a hostname with connect_to() instead of supplying an IP address.
|
|
bridge b2(connect_to("localhost:12345"), receive(in));
|
|
|
|
tsu_type msg;
|
|
bridge_status bs;
|
|
|
|
// Once a connection is established it will generate a status message from each bridge.
|
|
// Let's get those and print them.
|
|
b1_status.dequeue(bs);
|
|
cout << "bridge 1 status: is_connected: " << boolalpha << bs.is_connected << endl;
|
|
cout << "bridge 1 status: foreign_ip: " << bs.foreign_ip << endl;
|
|
cout << "bridge 1 status: foreign_port: " << bs.foreign_port << endl;
|
|
|
|
in.dequeue(msg);
|
|
bs = msg.get<bridge_status>();
|
|
cout << "bridge 2 status: is_connected: " << bs.is_connected << endl;
|
|
cout << "bridge 2 status: foreign_ip: " << bs.foreign_ip << endl;
|
|
cout << "bridge 2 status: foreign_port: " << bs.foreign_port << endl;
|
|
|
|
|
|
|
|
msg = 1;
|
|
out.enqueue(msg);
|
|
|
|
msg = 2;
|
|
out.enqueue(msg);
|
|
|
|
msg.get<my_example_object>().value = 3;
|
|
msg.get<my_example_object>().str = "some string";
|
|
out.enqueue(msg);
|
|
|
|
|
|
// Read the 3 things we sent over the connection.
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
in.dequeue(msg);
|
|
if (msg.contains<int>())
|
|
{
|
|
cout << "dequeued int: "<< msg.get<int>() << endl;
|
|
}
|
|
else if (msg.contains<my_example_object>())
|
|
{
|
|
cout << "dequeued struct: "<< msg.get<my_example_object>().value << " "
|
|
<< msg.get<my_example_object>().str << endl;
|
|
}
|
|
}
|
|
|
|
// cause bridge 1 to shutdown completely. This will close the connection and
|
|
// therefore bridge 2 will generate a status message indicating the connection
|
|
// just closed.
|
|
b1.clear();
|
|
in.dequeue(msg);
|
|
bs = msg.get<bridge_status>();
|
|
cout << "bridge 1 status: is_connected: " << bs.is_connected << endl;
|
|
cout << "bridge 1 status: foreign_ip: " << bs.foreign_ip << endl;
|
|
cout << "bridge 1 status: foreign_port: " << bs.foreign_port << endl;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|