void update(
std::string table,
std::vector<boost::optional<const char*>> fields,
T& values,
connection& db
)
{
std::ostringstream query;
query << "UPDATE " << table << " SET ";
auto query_fields = fields;
query_fields.erase(
std::remove_if(
query_fields.begin(),
query_fields.end(),
[](const boost::optional<const char*>& field) -> bool {
return !field;
}
),
query_fields.end()
);
json::serialise(
query_fields,
[](const boost::optional<const char*>& field, std::ostream& os) {
os << field.get() << " = ?";
},
", ",
query
);
// ID field
query << " WHERE " << T::id_field() << " = " << values.id();
sqlite3_stmt *stmt = nullptr;
if( sqlite3_prepare(
db.handle(),
query.str().c_str(),
-1,
&stmt,
nullptr
) != SQLITE_OK )
{
std::cerr << "Query: " << query.str() << std::endl;
throw std::runtime_error("Preparing SQLite statement for update");
}
bind_values(fields, values, stmt);
int step_ret = sqlite3_step(stmt);
if( step_ret != SQLITE_OK && step_ret != SQLITE_DONE )
{
std::ostringstream oss;
oss << "Stepping SQLite update " << sqlite3_errmsg(db.handle());
throw std::runtime_error(oss.str());
}
int finalise_ret = sqlite3_finalize(stmt);
if( finalise_ret != SQLITE_OK && finalise_ret != SQLITE_DONE)
{
std::ostringstream oss;
oss << "SQLite finalise " << sqlite3_errmsg(db.handle());
throw std::runtime_error(oss.str());
}
}
/// If the given `connection` `conn` is connected it gets added to the list of
/// tracked connections.
inline void add(connection conn) {
if(conn.connected()) {
m_conns.emplace_back(std::move(conn));
}
}
inline void swap(connection &conn1, connection &conn2)
{
conn1.swap(conn2);
}
int dijkstra(query_simple q, connection& result, simple_stats* st){
if(q.source_st == q.dest_st) return DIJ_NO_CONN;
bool* vis = new bool[num_vertices];
int* d = new int[num_vertices];
el_conn** p = new el_conn*[num_vertices];
int* wsk = new int[num_vertices + 1];
vbox* kop = new vbox[num_vertices + 1];
fill(vis, vis + num_vertices, false);
fill(d, d + num_vertices, INF_T);
fill(wsk, wsk + num_vertices + 1, 0);
d[q.source_st] = q.dep_time;
p[q.source_st] = NULL;
Heap* kol = new Heap(kop, wsk);
kol->push(vbox(-q.dep_time, q.source_st));
while(!kol->empty()){
int v = kol->pop();
st->num_pop ++;
if(vis[v]) continue;
st->num_vertices ++;
vis[v] = true;
if(v == q.dest_st) break;
for(vertex::iterator it = graph[v].begin(); it != graph[v].end(); it ++){
int u = it->first;
int nr = it->second;
el_conn* conn = edges[nr].get_after(d[v]);
if(conn == NULL) continue;
int nt = conn->arr_time;
if(nt < d[u]){
d[u] = nt;
p[u] = conn;
kol->push(vbox(-nt, u));
if(kol->size > st->max_heap)
st->max_heap = kol->size;
}
}
}
delete kol;
delete[] vis;
delete[] wsk;
delete[] kop;
if(d[q.dest_st] >= INF_T){
delete[] d;
delete[] p;
return DIJ_NO_CONN;
}
int w = q.dest_st;
while(p[w]){
result.push_back(*p[w]);
w = p[w]->dep_station;
}
result.sort();
delete[] p;
delete[] d;
return DIJ_OK;
}
static context::id id(const connection& c) { return id(c.pn_object()); }
void apply(connection& c) {
pn_connection_t *pnc = connection_options::pn_connection(c);
pn_transport_t *pnt = pn_connection_transport(pnc);
connector *outbound = dynamic_cast<connector*>(
connection_context::get(c).handler.get());
bool uninit = (c.state() & endpoint::LOCAL_UNINIT);
// pnt is NULL between reconnect attempts.
// Only apply transport options if uninit or outbound with
// transport not yet configured.
if (pnt && (uninit || (outbound && !outbound->transport_configured())))
{
// SSL
if (outbound && outbound->address().scheme() == url::AMQPS) {
pn_ssl_t *ssl = pn_ssl(pnt);
if (pn_ssl_init(ssl, ssl_client_options.value.pn_domain(), NULL))
throw error(MSG("client SSL/TLS initialization error"));
} else if (!outbound) {
pn_acceptor_t *pnp = pn_connection_acceptor(pnc);
if (pnp) {
listener_context &lc(listener_context::get(pnp));
if (lc.ssl) {
pn_ssl_t *ssl = pn_ssl(pnt);
if (pn_ssl_init(ssl, ssl_server_options.value.pn_domain(), NULL))
throw error(MSG("server SSL/TLS initialization error"));
}
}
}
// SASL
transport t = c.transport();
if (!sasl_enabled.set || sasl_enabled.value) {
if (sasl_enabled.set) // Explicitly set, not just default behaviour.
t.sasl(); // Force a sasl instance. Lazily create one otherwise.
if (sasl_allow_insecure_mechs.set)
t.sasl().allow_insecure_mechs(sasl_allow_insecure_mechs.value);
if (sasl_allowed_mechs.set)
t.sasl().allowed_mechs(sasl_allowed_mechs.value);
if (sasl_config_name.set)
t.sasl().config_name(sasl_config_name.value);
if (sasl_config_path.set)
t.sasl().config_path(sasl_config_path.value);
}
if (max_frame_size.set)
pn_transport_set_max_frame(pnt, max_frame_size.value);
if (max_channels.set)
pn_transport_set_channel_max(pnt, max_channels.value);
if (idle_timeout.set)
pn_transport_set_idle_timeout(pnt, idle_timeout.value.ms());
}
// Only apply connection options if uninit.
if (uninit) {
if (reconnect.set && outbound)
outbound->reconnect_timer(reconnect.value);
if (container_id.set)
pn_connection_set_container(pnc, container_id.value.c_str());
if (link_prefix.set)
connection_context::get(pnc).link_gen.prefix(link_prefix.value);
}
}
void handler::on_connection_error(connection &c) { on_error(c.error()); }
dns_requester::dns_requester(connection& aConnection) : whois_requester::requester(aConnection.whois()), iResolver(aConnection.connection_manager().resolver()), iConnection(aConnection)
{
iConnection.add_observer(*this);
}
void print_connection( connection const& c ) {
std::cerr << "Local address: " << c.local() << std::endl ;
std::cerr << "Peer address: " << c.peer () << std::endl ;
}
