C++ Router类代码示例

int main(void) {
    Router *router = new Router(OrthogonalRouting);
    router->setRoutingParameter((RoutingParameter)0, 2);
    router->setRoutingParameter((RoutingParameter)1, 0);
    router->setRoutingParameter((RoutingParameter)2, 0);
    router->setRoutingParameter((RoutingParameter)3, 4000);
    router->setRoutingParameter((RoutingParameter)4, 9000);
    router->setRoutingParameter((RoutingParameter)5, 0);
    router->setRoutingParameter((RoutingParameter)6, 0);
    router->setRoutingParameter((RoutingParameter)7, 16);
    router->setRoutingParameter((RoutingParameter)8, 0);
    router->setRoutingOption((RoutingOption)0, false);
    router->setRoutingOption((RoutingOption)1, true);
    router->setRoutingOption((RoutingOption)2, false);
    router->setRoutingOption((RoutingOption)3, false);
    router->setRoutingOption((RoutingOption)4, true);
    router->setRoutingOption((RoutingOption)5, false);
    router->setRoutingOption((RoutingOption)6, true);
    Polygon polygon;
    ConnEnd srcPt;
    ConnEnd dstPt;
    ConnEnd heConnPt;
    PolyLine newRoute;
    ShapeConnectionPin *connPin = NULL;

    // shapeRef1
    polygon = Polygon(4);
    polygon.ps[0] = Point(450, 330);
    polygon.ps[1] = Point(490, 330);
    polygon.ps[2] = Point(490, 450);
    polygon.ps[3] = Point(450, 450);
    ShapeRef *shapeRef1 = new ShapeRef(router, polygon, 1);
    connPin = new ShapeConnectionPin(shapeRef1, 1, 0, 0.333333, true, 10, (ConnDirFlags) 0);
    connPin->setExclusive(false);
    connPin = new ShapeConnectionPin(shapeRef1, 2, 0, 0.666667, true, 10, (ConnDirFlags) 0);
    connPin->setExclusive(false);
    connPin = new ShapeConnectionPin(shapeRef1, 3, 1, 0.5, true, 10, (ConnDirFlags) 0);
    connPin->setExclusive(false);
    connPin = new ShapeConnectionPin(shapeRef1, 4, 0.5, 0, true, 10, (ConnDirFlags) 0);
    connPin->setExclusive(false);

    // shapeRef8
    polygon = Polygon(4);
    polygon.ps[0] = Point(502, 237.5);
    polygon.ps[1] = Point(502, 262.5);
    polygon.ps[2] = Point(438, 262.5);
    polygon.ps[3] = Point(438, 237.5);
    ShapeRef *shapeRef8 = new ShapeRef(router, polygon, 8);
    connPin = new ShapeConnectionPin(shapeRef8, 1, 0, 0.5, true, 1, (ConnDirFlags) 0);
    connPin = new ShapeConnectionPin(shapeRef8, 2, 1, 0.5, true, 1, (ConnDirFlags) 0);
    connPin = new ShapeConnectionPin(shapeRef8, 3, 0.5, 1, true, 1, (ConnDirFlags) 0);
    connPin = new ShapeConnectionPin(shapeRef8, 4, 0.5, 0, true, 1, (ConnDirFlags) 0);

    JunctionRef *junctionRef6 = new JunctionRef(router, Point(470, 300), 6);
    /*
    // This may be useful if junction pins are modified.
    connPin = new ShapeConnectionPin(junctionRef6, 2147483646, (ConnDirFlags) 15);
    */

    // connRef9
    ConnRef *connRef9 = new ConnRef(router, 9);
    srcPt = ConnEnd(junctionRef6);
    connRef9->setSourceEndpoint(srcPt);
    dstPt = ConnEnd(shapeRef8, 3);
    connRef9->setDestEndpoint(dstPt);
    connRef9->setRoutingType((ConnType)2);

#if 1
    // connRef10 - WITH BUG
    ConnRef *connRef10 = new ConnRef(router, 10);
    srcPt = ConnEnd(junctionRef6);
    connRef10->setSourceEndpoint(srcPt);
    dstPt = ConnEnd(shapeRef1, 4);
    connRef10->setDestEndpoint(dstPt);
    connRef10->setRoutingType((ConnType)2);
#else
    // connRef10 - WITHOUT BUG
    ConnRef *connRef10 = new ConnRef(router, 10);
    srcPt = ConnEnd(shapeRef1, 4);
    connRef10->setSourceEndpoint(srcPt);
    dstPt = ConnEnd(junctionRef6);
    connRef10->setDestEndpoint(dstPt);
    connRef10->setRoutingType((ConnType)2);
#endif

    //    router->deleteConnector(connRef5);
    router->processTransaction();

    ConnRef *mergedConn = junctionRef6->removeJunctionAndMergeConnectors();
    router->processTransaction();
    router->outputDiagram("output/removeJunctions01");

    std::pair<ConnEnd, ConnEnd> ends = mergedConn->endpointConnEnds();

    // Expected result: output images should be virtually identical.
    // Result: An endpoint seems to be disconnected from shapeRef8.
    bool isConnected = (ends.first.shape() == shapeRef8) || (ends.second.shape() == shapeRef8);

    delete router;
    return isConnected ? 0 : 1;
//.........这里部分代码省略.........

int main(void) {
    Router *router = new Router(
            PolyLineRouting | OrthogonalRouting);
    router->setRoutingPenalty((PenaltyType)0, 50);
    router->setRoutingPenalty((PenaltyType)1, 0);
    router->setRoutingPenalty((PenaltyType)2, 200);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    //router->setRoutingPenalty((PenaltyType)4, 110);
    router->setOrthogonalNudgeDistance(25);

    double buffer = 4;
    Polygon poly342721632(4);
    poly342721632.ps[0] = Point(51910, 50946);
    poly342721632.ps[1] = Point(51910, 51004);
    poly342721632.ps[2] = Point(51825, 51004);
    poly342721632.ps[3] = Point(51825, 50946);
    ShapeRef *shapeRef342721632 = new ShapeRef(router, poly342721632, 342721632);
    new ShapeConnectionPin(shapeRef342721632, 1, 
            ATTACH_POS_LEFT, ATTACH_POS_CENTRE, buffer, ConnDirLeft);

    Polygon poly807558175(4);
    poly807558175.ps[0] = Point(51604, 51000);
    poly807558175.ps[1] = Point(51604, 51085);
    poly807558175.ps[2] = Point(51546, 51085);
    poly807558175.ps[3] = Point(51546, 51000);
    ShapeRef *shapeRef807558175 = new ShapeRef(router, poly807558175, 807558175);
    new ShapeConnectionPin(shapeRef807558175, 1, 
	    ATTACH_POS_CENTRE, ATTACH_POS_TOP, buffer, ConnDirNone);

    Polygon poly404900496(4);
    poly404900496.ps[0] = Point(51525, 50946);
    poly404900496.ps[1] = Point(51525, 51004);
    poly404900496.ps[2] = Point(51440, 51004);
    poly404900496.ps[3] = Point(51440, 50946);
    ShapeRef *shapeRef404900496 = new ShapeRef(router, poly404900496, 404900496);
    new ShapeConnectionPin(shapeRef404900496, 1, 
	    ATTACH_POS_RIGHT, ATTACH_POS_CENTRE, buffer, (ConnDirFlags) 8);

    JunctionRef *junctionRef265539540 = new JunctionRef(router, Point(51625, 50950), 265539540);

    ConnRef *connRef985644192 = new ConnRef(router, 985644192);
    ConnEnd srcPt985644192(shapeRef404900496, 1);
    connRef985644192->setSourceEndpoint(srcPt985644192);
    ConnEnd dstPt985644192(junctionRef265539540);
    connRef985644192->setDestEndpoint(dstPt985644192);
    connRef985644192->setRoutingType((ConnType)2);

    ConnRef *connRef467016913 = new ConnRef(router, 467016913);
    ConnEnd srcPt467016913(junctionRef265539540);
    connRef467016913->setSourceEndpoint(srcPt467016913);
    ConnEnd dstPt467016913(shapeRef807558175, 1);
    connRef467016913->setDestEndpoint(dstPt467016913);
    connRef467016913->setRoutingType((ConnType)2);

    ConnRef *connRef45740440 = new ConnRef(router, 45740440);
    ConnEnd srcPt45740440(shapeRef342721632, 1);
    connRef45740440->setSourceEndpoint(srcPt45740440);
    ConnEnd dstPt45740440(junctionRef265539540);
    connRef45740440->setDestEndpoint(dstPt45740440);
    connRef45740440->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-node1");
    delete router;
    return 0;
};

/**
 * Entry point into kwbrouter application.
 */
int main (int argc, char* argv[])
{
    int             rc = eERR_NONE;
    bool            end_application = false;
    options_t       options;
    ioloop_t        mainloop;

    do {
        // all logs on
        log_set_mask(0xFFFFFFFF);
        log_msg(KWB_LOG_INFO, "kwbrouter...");

        // set default options for kwbrouter
        set_options(&options,
                    "",                 // no serial device
                    57600,              // baudrate, if not given
                    "/tmp/kwbr.usk",    // default address of kwbrouter socket
                    0);                 // port 0: use unix sockets

        // parse and validate commandline options
        if (parse_commandline_options(argc, argv, &options) == false ||
            validate_options(&options) == false) {
            print_usage();
            rc = eERR_BAD_PARAMETER;
            break;
        }

        ioloop_init(&mainloop);

        Router* router = new Router();

        RConnSerial* serconn = new RConnSerial(&mainloop);
        serconn->Open(options.serial_device, options.serial_baudrate);

        router->AddConnection(serconn);

        // open new server and let-every connection auto-connect to router
        create_unix_socket_file(&options);
        SocketServer* server = new SocketServer(&mainloop, router);
        server->Open(options.router_address, options.router_port);

       // RConnSocketServer server = new
 /*
        route_init(&router);

        // initialize network routing
        msg_s_init(&msg_socket);
        if ((rc = msg_s_open_server(&msg_socket, &mainloop, "/tmp/kwb.usk", 0)) != eERR_NONE) {
            break;
        }
        msg_s_set_incomming_handler(&msg_socket, handle_incomming_msg, &router);
        msg_s_set_newconnection_handler(&msg_socket, handle_new_connection, &router);
        // add route for every client of unix socket
        ep = msg_s_get_endpoint(&msg_socket, 0, eMSG_EP_COMM);

        // initialize bus routing
        msg_b_init(&msg_bus, 0);
        if (options.serial_device_set) {
            address = options.serial_device;
            port = options.serial_baudrate;
            serial = true;
        } else {
            address = options.vbusd_address;
            port = options.vbusd_port;
            serial = false;
        }
        rc = msg_b_open(&msg_bus, &mainloop, options.own_node_address, serial,
                        address, port);
        if (rc != eERR_NONE) break;
        msg_b_set_incomming_handler(&msg_bus, handle_incomming_msg, &router);
        route_add(&router, 1, 65535, address, port, eROUTE_TYPE_SERIAL, &msg_bus);
*/
        log_msg(KWB_LOG_STATUS, "entering mainloop...\n");
        while (!end_application) {
            ioloop_run_once(&mainloop);
        }

        server->Close();
        delete server;

        router->RemoveConnection(serconn);
        serconn->Close();
        delete serconn;

        delete router;
    } while (0);
    return rc;
}

int main(void) {
    Router *router = new Router(
            PolyLineRouting | OrthogonalRouting);
    router->setRoutingPenalty((PenaltyType)0, 50);
    router->setRoutingPenalty((PenaltyType)1, 0);
    router->setRoutingPenalty((PenaltyType)2, 200);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    router->setRoutingPenalty((PenaltyType)4, 9000);
    router->setRoutingPenalty((PenaltyType)5, 100);
    router->setRoutingOption((RoutingOption)0, false);
    router->setRoutingOption((RoutingOption)1, true);
    router->setRoutingOption((RoutingOption)2, true);
    router->setRoutingOption(improveHyperedgeRoutesMovingAddingAndDeletingJunctions, true);
    router->setRoutingParameter(idealNudgingDistance, 25);

    Polygon poly39761567(4);
    poly39761567.ps[0] = Point(50754, 50975);
    poly39761567.ps[1] = Point(50754, 51060);
    poly39761567.ps[2] = Point(50696, 51060);
    poly39761567.ps[3] = Point(50696, 50975);
    ShapeRef *shapeRef39761567 = new ShapeRef(router, poly39761567, 39761567);
    new ShapeConnectionPin(shapeRef39761567, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    Polygon poly115776716(4);
    poly115776716.ps[0] = Point(51504, 50975);
    poly115776716.ps[1] = Point(51504, 51060);
    poly115776716.ps[2] = Point(51446, 51060);
    poly115776716.ps[3] = Point(51446, 50975);
    ShapeRef *shapeRef115776716 = new ShapeRef(router, poly115776716, 115776716);
    new ShapeConnectionPin(shapeRef115776716, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    Polygon poly238475293(4);
    poly238475293.ps[0] = Point(50554, 50975);
    poly238475293.ps[1] = Point(50554, 51060);
    poly238475293.ps[2] = Point(50496, 51060);
    poly238475293.ps[3] = Point(50496, 50975);
    ShapeRef *shapeRef238475293 = new ShapeRef(router, poly238475293, 238475293);
    new ShapeConnectionPin(shapeRef238475293, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    Polygon poly430971008(4);
    poly430971008.ps[0] = Point(51004, 50975);
    poly430971008.ps[1] = Point(51004, 51060);
    poly430971008.ps[2] = Point(50946, 51060);
    poly430971008.ps[3] = Point(50946, 50975);
    ShapeRef *shapeRef430971008 = new ShapeRef(router, poly430971008, 430971008);
    new ShapeConnectionPin(shapeRef430971008, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    JunctionRef *junctionRef513246008 = new JunctionRef(router, Point(50925, 50725), 513246008);
    /*
    // This may be useful if junction pins are modified.
    new ShapeConnectionPin(junctionRef513246008, 2147483646, (ConnDirFlags) 15);
    */

    ConnRef *connRef513246009 = new ConnRef(router, 513246009);
    ConnEnd srcPt513246009(shapeRef39761567, 1);
    connRef513246009->setSourceEndpoint(srcPt513246009);
    ConnEnd dstPt513246009(junctionRef513246008);
    connRef513246009->setDestEndpoint(dstPt513246009);
    connRef513246009->setRoutingType((ConnType)2);

    ConnRef *connRef513246010 = new ConnRef(router, 513246010);
    ConnEnd srcPt513246010(junctionRef513246008);
    connRef513246010->setSourceEndpoint(srcPt513246010);
    ConnEnd dstPt513246010(shapeRef430971008, 1);
    connRef513246010->setDestEndpoint(dstPt513246010);
    connRef513246010->setRoutingType((ConnType)2);

    ConnRef *connRef513246011 = new ConnRef(router, 513246011);
    ConnEnd srcPt513246011(junctionRef513246008);
    connRef513246011->setSourceEndpoint(srcPt513246011);
    ConnEnd dstPt513246011(shapeRef238475293, 1);
    connRef513246011->setDestEndpoint(dstPt513246011);
    connRef513246011->setRoutingType((ConnType)2);

    ConnRef *connRef513246012 = new ConnRef(router, 513246012);
    ConnEnd srcPt513246012(shapeRef115776716, 1);
    connRef513246012->setSourceEndpoint(srcPt513246012);
    ConnEnd dstPt513246012(junctionRef513246008);
    connRef513246012->setDestEndpoint(dstPt513246012);
    connRef513246012->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("output/improveHyperedge03");

    bool overlaps = router->existsOrthogonalSegmentOverlap(true);
    delete router;
    return (overlaps) ? 1 : 0;
};

void Admin::GetOperation(const Operation & op, OpVector & res)
{
    const std::vector<Root> & args = op->getArgs();
    if (args.empty()) {
        error(op, "Get has no args.", res, getId());
        return;
    }
    const Root & arg = args.front();
    if (!arg->hasAttrFlag(Atlas::Objects::OBJTYPE_FLAG)) {
        error(op, "Get arg has no objtype.", res, getId());
        return;
    }
    const std::string & objtype = arg->getObjtype();
    if (!arg->hasAttrFlag(Atlas::Objects::ID_FLAG)) {
        error(op, "Get arg has no id.", res, getId());
        return;
    }
    const std::string & id = arg->getId();
    if (id.empty()) {
        error(op, "Get arg id empty", res, getId());
        return;
    }
    Info info;
    if (objtype == "object" || objtype == "obj") {
        if (m_connection == 0) {
            return;
        }
        long intId = integerId(id);

        const RouterMap & OOGDict = m_connection->m_server.getObjects();
        RouterMap::const_iterator J = OOGDict.find(intId);
        const EntityDict & worldDict = m_connection->m_server.m_world.getEntities();
        EntityDict::const_iterator K = worldDict.find(intId);

        if (J != OOGDict.end()) {
            Router * obj = J->second;
            Anonymous info_arg;
            obj->addToEntity(info_arg);
            info->setArgs1(info_arg);
        } else if (K != worldDict.end()) {
            Anonymous info_arg;
            K->second->addToEntity(info_arg);
            info->setArgs1(info_arg);
        } else {
            clientError(op, compose("Unknown object id \"%1\" requested", id),
                        res, getId());
            return;
        }
    } else if (objtype == "class" ||
               objtype == "meta" ||
               objtype == "op_definition") {
        const Root & o = Inheritance::instance().getClass(id);
        if (!o.isValid()) {
            clientError(op, compose("Unknown type definition for \"%1\" "
                                    "requested", id), res);
            return;
        }
        info->setArgs1(o);
    } else {
        error(op, compose("Unknown object type \"%1\" requested for \"%2\"",
                          objtype, id), res, getId());
        return;
    }
    res.push_back(info);
}

int main(void) {
    Router *router = new Router(
            PolyLineRouting | OrthogonalRouting);
    router->setRoutingPenalty((PenaltyType)0, 50);
    router->setRoutingPenalty((PenaltyType)1, 0);
    router->setRoutingPenalty((PenaltyType)2, 0);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    router->setRoutingPenalty((PenaltyType)4, 110);
    router->setOrthogonalNudgeDistance(25);

    Polygon poly143407352(4);
    poly143407352.ps[0] = Point(6035, 4390);
    poly143407352.ps[1] = Point(6035, 5085);
    poly143407352.ps[2] = Point(5675, 5085);
    poly143407352.ps[3] = Point(5675, 4390);
    new ShapeRef(router, poly143407352, 143407352);
    
    Polygon poly124950386(4);
    poly124950386.ps[0] = Point(4900, 4090);
    poly124950386.ps[1] = Point(4900, 4785);
    poly124950386.ps[2] = Point(4540, 4785);
    poly124950386.ps[3] = Point(4540, 4090);
    new ShapeRef(router, poly124950386, 124950386);
    
    ConnRef *connRef373967044 = new ConnRef(router, 373967044);
    ConnEnd srcPt373967044(Point(4890, 4250), 8);
    connRef373967044->setSourceEndpoint(srcPt373967044);
    ConnEnd dstPt373967044(Point(5685, 4550), 4);
    connRef373967044->setDestEndpoint(dstPt373967044);
    connRef373967044->setRoutingType((ConnType)2);

    ConnRef *connRef681881486 = new ConnRef(router, 681881486);
    ConnEnd srcPt681881486(Point(4890, 4325), 8);
    connRef681881486->setSourceEndpoint(srcPt681881486);
    ConnEnd dstPt681881486(Point(5685, 4625), 4);
    connRef681881486->setDestEndpoint(dstPt681881486);
    connRef681881486->setRoutingType((ConnType)2);

    ConnRef *connRef829752 = new ConnRef(router, 829752);
    ConnEnd srcPt829752(Point(4890, 4400), 8);
    connRef829752->setSourceEndpoint(srcPt829752);
    ConnEnd dstPt829752(Point(5685, 4700), 4);
    connRef829752->setDestEndpoint(dstPt829752);
    connRef829752->setRoutingType((ConnType)2);

    ConnRef *connRef17625739 = new ConnRef(router, 17625739);
    ConnEnd srcPt17625739(Point(4890, 4475), 8);
    connRef17625739->setSourceEndpoint(srcPt17625739);
    ConnEnd dstPt17625739(Point(5685, 4775), 4);
    connRef17625739->setDestEndpoint(dstPt17625739);
    connRef17625739->setRoutingType((ConnType)2);

    ConnRef *connRef223864175 = new ConnRef(router, 223864175);
    ConnEnd srcPt223864175(Point(4890, 4550), 8);
    connRef223864175->setSourceEndpoint(srcPt223864175);
    ConnEnd dstPt223864175(Point(5685, 4850), 4);
    connRef223864175->setDestEndpoint(dstPt223864175);
    connRef223864175->setRoutingType((ConnType)2);

    ConnRef *connRef98144280 = new ConnRef(router, 98144280);
    ConnEnd srcPt98144280(Point(4890, 4625), 8);
    connRef98144280->setSourceEndpoint(srcPt98144280);
    ConnEnd dstPt98144280(Point(5685, 4925), 4);
    connRef98144280->setDestEndpoint(dstPt98144280);
    connRef98144280->setRoutingType((ConnType)2);

    ConnRef *connRef283100856 = new ConnRef(router, 283100856);
    ConnEnd srcPt283100856(Point(4890, 4700), 8);
    connRef283100856->setSourceEndpoint(srcPt283100856);
    ConnEnd dstPt283100856(Point(5685, 5000), 4);
    connRef283100856->setDestEndpoint(dstPt283100856);
    connRef283100856->setRoutingType((ConnType)2);

    ConnRef *connRef387080925 = new ConnRef(router, 387080925);
    ConnEnd srcPt387080925(Point(5685, 4475), 4);
    connRef387080925->setSourceEndpoint(srcPt387080925);
    ConnEnd dstPt387080925(Point(4890, 4175), 8);
    connRef387080925->setDestEndpoint(dstPt387080925);
    connRef387080925->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-orthordering-02");
    int crossings = router->existsOrthogonalCrossings();
    delete router;
    return (crossings > 0) ? 1 : 0;
};

void NetworkTreeNode::inferRouters()
{
    if(inferredRouters.size() > 0)
    {
        return;
    }

    list<InetAddress*> interfaces = this->listInterfaces();
    
    // Remove duplicata (possible because ingress interface of neighborhood can be a contra-pivot)
    InetAddress previous(0);
    bool previousAssigned = false;
    for(list<InetAddress*>::iterator i = interfaces.begin(); i != interfaces.end(); ++i)
    {
        InetAddress *current = (*i);
        
        if(current == NULL)
            continue;
        
        if(previousAssigned && (*current) == previous)
            interfaces.erase(i--);
        
        previous = (*current);
        if(!previousAssigned)
            previousAssigned = true;
    }

    // First compute the smallest gap between IP IDs.
    unsigned short smallestGap = 65335;
    bool noHostNames = true;
    for(list<InetAddress*>::iterator i = interfaces.begin(); i != interfaces.end(); ++i)
    {
        for(list<InetAddress*>::iterator j = i; j != interfaces.end(); ++j)
        {
            if((*i) == (*j))
                continue;
            
            if(!(*i)->getStoredHostName().empty() && !(*j)->getStoredHostName().empty())
                noHostNames = false;
            
            if((*i)->hasIPIdentifier() && (*j)->hasIPIdentifier())
            {
                unsigned short thisGap = 0;
                unsigned short IPId1 = (*i)->getIPIdentifier();
                unsigned short IPId2 = (*j)->getIPIdentifier();
                if(IPId1 > IPId2)
                    thisGap = IPId1 - IPId2;
                else
                    thisGap = IPId2 - IPId1;
                
                if(thisGap > (65535 - MAX_IP_ID_DIFFERENCE))
                {
                    if(IPId1 > 60000)
                        thisGap = (65535 - IPId1) + IPId2;
                    else
                        thisGap = (65535 - IPId2) + IPId1;
                }
                
                if(thisGap < smallestGap)
                    smallestGap = thisGap;
            }
        }
    }
    
    // If not enough host names, above a threshold (for the gap), infers a router per interface.
    if(noHostNames && smallestGap > NO_ASSOCIATION_THRESHOLD)
    {
        for(list<InetAddress*>::iterator i = interfaces.begin(); i != interfaces.end(); ++i)
        {
            Router *curRouter = new Router();
            curRouter->addInterface(InetAddress(*(*i)));
            inferredRouters.push_back(curRouter);
        }
        
        /*
         * Some post-processing: removes the routers consisting of a single interface which happens 
         * to be a candidate contra-pivot of an ODD subnet.
         *
         * N.B.: checking the interface appears in the subnet responsive IPs list is enough, as the 
         * pivots were not listed at all in the potential interfaces.
         */
         
        for(list<Router*>::iterator i = inferredRouters.begin(); i != inferredRouters.end(); ++i)
        {
            if((*i)->getNbInterfaces() == 1)
            {
                InetAddress singleInterface = (*i)->getInterfacesList()->front();
                for(list<NetworkTreeNode*>::iterator j = children.begin(); j != children.end(); ++j)
                {
                    if((*j)->getType() == NetworkTreeNode::T_SUBNET)
                    {
                        SubnetSite *ss = (*j)->getAssociatedSubnet();
                        
                        if(ss->getStatus() == SubnetSite::ODD_SUBNET && 
                           ss->hasLiveInterface(singleInterface))
                        {
                            bool isALabel = false;
                            for(list<InetAddress>::iterator k = labels.begin(); 
                                k != labels.end(); 
                                ++k)
//.........这里部分代码省略.........

void main()
{
	Router router;
	router.Run();
}

int main(void) {
    Router *router = new Router(
        PolyLineRouting | OrthogonalRouting);
    router->setRoutingPenalty((PenaltyType)0, 50);
    router->setRoutingPenalty((PenaltyType)1, 0);
    router->setRoutingPenalty((PenaltyType)2, 200);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    router->setRoutingPenalty((PenaltyType)4, 110);
    router->setRoutingParameter(idealNudgingDistance, 25);

    Polygon poly282634758(4);
    poly282634758.ps[0] = Point(51360, 50215);
    poly282634758.ps[1] = Point(51360, 50460);
    poly282634758.ps[2] = Point(51075, 50460);
    poly282634758.ps[3] = Point(51075, 50215);
    new ShapeRef(router, poly282634758, 282634758);

    Polygon poly69386928(4);
    poly69386928.ps[0] = Point(51050, 50415);
    poly69386928.ps[1] = Point(51050, 50735);
    poly69386928.ps[2] = Point(50690, 50735);
    poly69386928.ps[3] = Point(50690, 50415);
    new ShapeRef(router, poly69386928, 69386928);

    Polygon poly11958280(4);
    poly11958280.ps[0] = Point(50460, 50490);
    poly11958280.ps[1] = Point(50460, 50660);
    poly11958280.ps[2] = Point(50290, 50660);
    poly11958280.ps[3] = Point(50290, 50490);
    new ShapeRef(router, poly11958280, 11958280);

    Polygon poly50591298(4);
    poly50591298.ps[0] = Point(51260, 50015);
    poly50591298.ps[1] = Point(51260, 50185);
    poly50591298.ps[2] = Point(51075, 50185);
    poly50591298.ps[3] = Point(51075, 50015);
    new ShapeRef(router, poly50591298, 50591298);

    ConnRef *connRef355676284 = new ConnRef(router, 355676284);
    ConnEnd srcPt355676284(Point(51040, 50575), 8);
    connRef355676284->setSourceEndpoint(srcPt355676284);
    ConnEnd dstPt355676284(Point(51085, 50300), 4);
    connRef355676284->setDestEndpoint(dstPt355676284);
    connRef355676284->setRoutingType((ConnType)2);

    ConnRef *connRef33653259 = new ConnRef(router, 33653259);
    ConnEnd srcPt33653259(Point(51040, 50650), 8);
    connRef33653259->setSourceEndpoint(srcPt33653259);
    ConnEnd dstPt33653259(Point(51085, 50375), 4);
    connRef33653259->setDestEndpoint(dstPt33653259);
    connRef33653259->setRoutingType((ConnType)2);

    ConnRef *connRef421608980 = new ConnRef(router, 421608980);
    ConnEnd srcPt421608980(Point(51040, 50500), 8);
    connRef421608980->setSourceEndpoint(srcPt421608980);
    ConnEnd dstPt421608980(Point(51085, 50100), 4);
    connRef421608980->setDestEndpoint(dstPt421608980);
    connRef421608980->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputDiagram("output/restrictedNudging");

    bool overlap = router->existsOrthogonalTouchingPaths();
    delete router;
    return (overlap) ? 1 : 0;
};

int main(void) {
    Router *router = new Router(
            PolyLineRouting | OrthogonalRouting);
    router->setRoutingPenalty((PenaltyType)0, 50);
    router->setRoutingPenalty((PenaltyType)1, 0);
    router->setRoutingPenalty((PenaltyType)2, 0);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    router->setRoutingPenalty((PenaltyType)4, 110);
    router->setOrthogonalNudgeDistance(25);

    Polygon poly426345871(4);
    poly426345871.ps[0] = Point(7200, 5240);
    poly426345871.ps[1] = Point(7200, 5660);
    poly426345871.ps[2] = Point(6690, 5660);
    poly426345871.ps[3] = Point(6690, 5240);
    ShapeRef *shapeRef426345871 = new ShapeRef(router, poly426345871, 426345871);
    router->addShape(shapeRef426345871);

    Polygon poly596896212(4);
    poly596896212.ps[0] = Point(7200, 5740);
    poly596896212.ps[1] = Point(7200, 6160);
    poly596896212.ps[2] = Point(6690, 6160);
    poly596896212.ps[3] = Point(6690, 5740);
    ShapeRef *shapeRef596896212 = new ShapeRef(router, poly596896212, 596896212);
    router->addShape(shapeRef596896212);

    ConnRef *connRef20026701 = new ConnRef(router, 20026701);
    ConnEnd srcPt20026701(Point(7190, 5600), 8);
    connRef20026701->setSourceEndpoint(srcPt20026701);
    ConnEnd dstPt20026701(Point(7190, 5800), 8);
    connRef20026701->setDestEndpoint(dstPt20026701);
    connRef20026701->setRoutingType((ConnType)2);

    ConnRef *connRef124776000 = new ConnRef(router, 124776000);
    ConnEnd srcPt124776000(Point(7190, 5550), 8);
    connRef124776000->setSourceEndpoint(srcPt124776000);
    ConnEnd dstPt124776000(Point(7190, 5850), 8);
    connRef124776000->setDestEndpoint(dstPt124776000);
    connRef124776000->setRoutingType((ConnType)2);

    ConnRef *connRef162425002 = new ConnRef(router, 162425002);
    ConnEnd srcPt162425002(Point(7190, 5500), 8);
    connRef162425002->setSourceEndpoint(srcPt162425002);
    ConnEnd dstPt162425002(Point(7190, 5900), 8);
    connRef162425002->setDestEndpoint(dstPt162425002);
    connRef162425002->setRoutingType((ConnType)2);

    ConnRef *connRef445102866 = new ConnRef(router, 445102866);
    ConnEnd srcPt445102866(Point(7190, 5450), 8);
    connRef445102866->setSourceEndpoint(srcPt445102866);
    ConnEnd dstPt445102866(Point(7190, 5950), 8);
    connRef445102866->setDestEndpoint(dstPt445102866);
    connRef445102866->setRoutingType((ConnType)2);

    ConnRef *connRef472520508 = new ConnRef(router, 472520508);
    ConnEnd srcPt472520508(Point(7190, 5400), 8);
    connRef472520508->setSourceEndpoint(srcPt472520508);
    ConnEnd dstPt472520508(Point(7190, 6000), 8);
    connRef472520508->setDestEndpoint(dstPt472520508);
    connRef472520508->setRoutingType((ConnType)2);

    ConnRef *connRef406587600 = new ConnRef(router, 406587600);
    ConnEnd srcPt406587600(Point(7190, 5350), 8);
    connRef406587600->setSourceEndpoint(srcPt406587600);
    ConnEnd dstPt406587600(Point(7190, 6050), 8);
    connRef406587600->setDestEndpoint(dstPt406587600);
    connRef406587600->setRoutingType((ConnType)2);

    ConnRef *connRef41657796 = new ConnRef(router, 41657796);
    ConnEnd srcPt41657796(Point(7190, 5300), 8);
    connRef41657796->setSourceEndpoint(srcPt41657796);
    ConnEnd dstPt41657796(Point(7190, 6100), 8);
    connRef41657796->setDestEndpoint(dstPt41657796);
    connRef41657796->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-nudgeold");
    delete router;
    return 0;
};

int main(void) {
    Router *router = new Router(OrthogonalRouting);
    router->setRoutingParameter((RoutingParameter)0, 10);
    router->setRoutingParameter((RoutingParameter)1, 0);
    router->setRoutingParameter((RoutingParameter)2, 1000);
    router->setRoutingParameter((RoutingParameter)3, 4000);
    router->setRoutingParameter((RoutingParameter)4, 0);
    router->setRoutingParameter((RoutingParameter)5, 100);
    router->setRoutingParameter((RoutingParameter)6, 1);
    router->setRoutingParameter((RoutingParameter)7, 10);
    router->setRoutingParameter(reverseDirectionPenalty, 500);
    router->setRoutingOption((RoutingOption)0, false);
    router->setRoutingOption((RoutingOption)1, true);
    router->setRoutingOption((RoutingOption)2, false);
    router->setRoutingOption((RoutingOption)3, false);
    router->setRoutingOption((RoutingOption)4, true);
    router->setRoutingOption((RoutingOption)5, true);
    Polygon polygon;
    ConnRef *connRef = NULL;
    ConnEnd srcPt;
    ConnEnd dstPt;
    PolyLine newRoute;
    // shapeRef1
    polygon = Polygon(4);
    polygon.ps[0] = Point(0, 0);
    polygon.ps[1] = Point(0, 0);
    polygon.ps[2] = Point(0, 0);
    polygon.ps[3] = Point(0, 0);
    new ShapeRef(router, polygon, 1);

    // shapeRef2
    polygon = Polygon(4);
    polygon.ps[0] = Point(0, 0);
    polygon.ps[1] = Point(0, 0);
    polygon.ps[2] = Point(0, 0);
    polygon.ps[3] = Point(0, 0);
    new ShapeRef(router, polygon, 2);

    // shapeRef3
    polygon = Polygon(4);
    polygon.ps[0] = Point(0, 0);
    polygon.ps[1] = Point(0, 0);
    polygon.ps[2] = Point(0, 0);
    polygon.ps[3] = Point(0, 0);
    new ShapeRef(router, polygon, 3);

    // shapeRef4
    polygon = Polygon(4);
    polygon.ps[0] = Point(0, 0);
    polygon.ps[1] = Point(0, 0);
    polygon.ps[2] = Point(0, 0);
    polygon.ps[3] = Point(0, 0);
    new ShapeRef(router, polygon, 4);

    // shapeRef5
    polygon = Polygon(4);
    polygon.ps[0] = Point(501, 345);
    polygon.ps[1] = Point(501, 404);
    polygon.ps[2] = Point(421, 404);
    polygon.ps[3] = Point(421, 345);
    ShapeRef *shapeRef5 = new ShapeRef(router, polygon, 5);
    new ShapeConnectionPin(shapeRef5, 5, 1, 0.652542, true, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef5, 6, 0, 0.79096, true, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef5, 7, 0, 0.514124, true, 0, (ConnDirFlags) 4);

    // shapeRef6
    polygon = Polygon(4);
    polygon.ps[0] = Point(94, 251.5);
    polygon.ps[1] = Point(94, 315.5);
    polygon.ps[2] = Point(12, 315.5);
    polygon.ps[3] = Point(12, 251.5);
    ShapeRef *shapeRef6 = new ShapeRef(router, polygon, 6);
    new ShapeConnectionPin(shapeRef6, 8, 1, 0.640625, true, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef6, 9, 0, 0.640625, true, 0, (ConnDirFlags) 4);

    // shapeRef7
    polygon = Polygon(4);
    polygon.ps[0] = Point(634.366, 262);
    polygon.ps[1] = Point(634.366, 305);
    polygon.ps[2] = Point(416.366, 305);
    polygon.ps[3] = Point(416.366, 262);
    ShapeRef *shapeRef7 = new ShapeRef(router, polygon, 7);
    new ShapeConnectionPin(shapeRef7, 10, 1, 0.709302, true, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef7, 11, 0, 0.709302, true, 0, (ConnDirFlags) 4);

    // shapeRef8
    polygon = Polygon(4);
    polygon.ps[0] = Point(324, 147.167);
    polygon.ps[1] = Point(324, 206.167);
    polygon.ps[2] = Point(236, 206.167);
    polygon.ps[3] = Point(236, 147.167);
    ShapeRef *shapeRef8 = new ShapeRef(router, polygon, 8);
    new ShapeConnectionPin(shapeRef8, 12, 1, 0.652542, true, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef8, 13, 0, 0.79096, true, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef8, 14, 0, 0.514124, true, 0, (ConnDirFlags) 4);

    // shapeRef9
    polygon = Polygon(4);
    polygon.ps[0] = Point(816, 353.167);
    polygon.ps[1] = Point(816, 412.167);
//.........这里部分代码省略.........

int main(void) {
    Router *router = new Router(
            PolyLineRouting | OrthogonalRouting);
    router->setRoutingPenalty((PenaltyType)0, 50);
    router->setRoutingPenalty((PenaltyType)1, 0);
    router->setRoutingPenalty((PenaltyType)2, 200);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    router->setRoutingPenalty((PenaltyType)4, 110);
    router->setRoutingPenalty((PenaltyType)5, 100);
    router->setRoutingOption((RoutingOption)0, false);
    router->setRoutingOption((RoutingOption)1, true);
    router->setRoutingParameter(idealNudgingDistance, 25);

    Polygon poly3075375(4);
    poly3075375.ps[0] = Point(51925, 52070);
    poly3075375.ps[1] = Point(51925, 52130);
    poly3075375.ps[2] = Point(51725, 52130);
    poly3075375.ps[3] = Point(51725, 52070);
    new ShapeRef(router, poly3075375, 3075375);

    Polygon poly101599344(4);
    poly101599344.ps[0] = Point(50275, 52410);
    poly101599344.ps[1] = Point(50275, 52490);
    poly101599344.ps[2] = Point(50075, 52490);
    poly101599344.ps[3] = Point(50075, 52410);
    new ShapeRef(router, poly101599344, 101599344);

    Polygon poly127957550(4);
    poly127957550.ps[0] = Point(52010, 51617);
    poly127957550.ps[1] = Point(52010, 51683);
    poly127957550.ps[2] = Point(51890, 51683);
    poly127957550.ps[3] = Point(51890, 51617);
    ShapeRef *shapeRef127957550 = new ShapeRef(router, poly127957550, 127957550);
    new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 1);
    new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 2);
    new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 8);

    Polygon poly129612347(4);
    poly129612347.ps[0] = Point(51900, 51696);
    poly129612347.ps[1] = Point(51900, 51754);
    poly129612347.ps[2] = Point(51815, 51754);
    poly129612347.ps[3] = Point(51815, 51696);
    new ShapeRef(router, poly129612347, 129612347);

    Polygon poly203389050(4);
    poly203389050.ps[0] = Point(51825, 52260);
    poly203389050.ps[1] = Point(51825, 52340);
    poly203389050.ps[2] = Point(51625, 52340);
    poly203389050.ps[3] = Point(51625, 52260);
    new ShapeRef(router, poly203389050, 203389050);

    Polygon poly208676910(4);
    poly208676910.ps[0] = Point(51950, 51760);
    poly208676910.ps[1] = Point(51950, 51840);
    poly208676910.ps[2] = Point(51750, 51840);
    poly208676910.ps[3] = Point(51750, 51760);
    new ShapeRef(router, poly208676910, 208676910);

    Polygon poly219117032(4);
    poly219117032.ps[0] = Point(50225, 52070);
    poly219117032.ps[1] = Point(50225, 52130);
    poly219117032.ps[2] = Point(50025, 52130);
    poly219117032.ps[3] = Point(50025, 52070);
    new ShapeRef(router, poly219117032, 219117032);

    Polygon poly258454350(4);
    poly258454350.ps[0] = Point(50185, 51617);
    poly258454350.ps[1] = Point(50185, 51683);
    poly258454350.ps[2] = Point(50065, 51683);
    poly258454350.ps[3] = Point(50065, 51617);
    ShapeRef *shapeRef258454350 = new ShapeRef(router, poly258454350, 258454350);
    new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 1);
    new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 2);
    new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 8);

    Polygon poly274504590(4);
    poly274504590.ps[0] = Point(51400, 52470);
    poly274504590.ps[1] = Point(51400, 52530);
    poly274504590.ps[2] = Point(51150, 52530);
    poly274504590.ps[3] = Point(51150, 52470);
    new ShapeRef(router, poly274504590, 274504590);

    Polygon poly320957826(4);
    poly320957826.ps[0] = Point(50275, 51910);
    poly320957826.ps[1] = Point(50275, 51990);
    poly320957826.ps[2] = Point(50075, 51990);
    poly320957826.ps[3] = Point(50075, 51910);
    new ShapeRef(router, poly320957826, 320957826);

    Polygon poly368436384(4);
    poly368436384.ps[0] = Point(50325, 51696);
    poly368436384.ps[1] = Point(50325, 51754);
    poly368436384.ps[2] = Point(50240, 51754);
    poly368436384.ps[3] = Point(50240, 51696);
    new ShapeRef(router, poly368436384, 368436384);

    Polygon poly381499178(4);
    poly381499178.ps[0] = Point(51850, 51345);
//.........这里部分代码省略.........

int main(void) {
    Router *router = new Router(
            PolyLineRouting | OrthogonalRouting);
    router->setRoutingPenalty((PenaltyType)0, 50);
    router->setRoutingPenalty((PenaltyType)1, 0);
    router->setRoutingPenalty((PenaltyType)2, 0);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    router->setRoutingPenalty((PenaltyType)4, 110);
    router->setOrthogonalNudgeDistance(12);

    Polygon poly21424960(4);
    poly21424960.ps[0] = Point(29950, 27210);
    poly21424960.ps[1] = Point(29950, 27290);
    poly21424960.ps[2] = Point(29700, 27290);
    poly21424960.ps[3] = Point(29700, 27210);
    new ShapeRef(router, poly21424960, 21424960);
    
    Polygon poly435105790(4);
    poly435105790.ps[0] = Point(29950, 27110);
    poly435105790.ps[1] = Point(29950, 27190);
    poly435105790.ps[2] = Point(29700, 27190);
    poly435105790.ps[3] = Point(29700, 27110);
    new ShapeRef(router, poly435105790, 435105790);
    
    Polygon poly40787191(4);
    poly40787191.ps[0] = Point(29950, 27010);
    poly40787191.ps[1] = Point(29950, 27090);
    poly40787191.ps[2] = Point(29700, 27090);
    poly40787191.ps[3] = Point(29700, 27010);
    new ShapeRef(router, poly40787191, 40787191);
    
    Polygon poly76911264(4);
    poly76911264.ps[0] = Point(29950, 26910);
    poly76911264.ps[1] = Point(29950, 26990);
    poly76911264.ps[2] = Point(29700, 26990);
    poly76911264.ps[3] = Point(29700, 26910);
    new ShapeRef(router, poly76911264, 76911264);
    
    Polygon poly506213376(4);
    poly506213376.ps[0] = Point(29925, 26820);
    poly506213376.ps[1] = Point(29925, 26880);
    poly506213376.ps[2] = Point(29675, 26880);
    poly506213376.ps[3] = Point(29675, 26820);
    new ShapeRef(router, poly506213376, 506213376);
    
    Polygon poly134604636(4);
    poly134604636.ps[0] = Point(29925, 26720);
    poly134604636.ps[1] = Point(29925, 26780);
    poly134604636.ps[2] = Point(29675, 26780);
    poly134604636.ps[3] = Point(29675, 26720);
    new ShapeRef(router, poly134604636, 134604636);
    
    Polygon poly14353632(4);
    poly14353632.ps[0] = Point(29600, 26590);
    poly14353632.ps[1] = Point(29600, 27660);
    poly14353632.ps[2] = Point(28440, 27660);
    poly14353632.ps[3] = Point(28440, 26590);
    new ShapeRef(router, poly14353632, 14353632);
    
    ConnRef *connRef70269732 = new ConnRef(router, 70269732);
    ConnEnd srcPt70269732(Point(29590, 26700), 8);
    connRef70269732->setSourceEndpoint(srcPt70269732);
    ConnEnd dstPt70269732(Point(29915, 26750), 8);
    connRef70269732->setDestEndpoint(dstPt70269732);
    connRef70269732->setRoutingType((ConnType)2);

    ConnRef *connRef371572709 = new ConnRef(router, 371572709);
    ConnEnd srcPt371572709(Point(29590, 26800), 8);
    connRef371572709->setSourceEndpoint(srcPt371572709);
    ConnEnd dstPt371572709(Point(29915, 26850), 8);
    connRef371572709->setDestEndpoint(dstPt371572709);
    connRef371572709->setRoutingType((ConnType)2);

    ConnRef *connRef876797766 = new ConnRef(router, 876797766);
    ConnEnd srcPt876797766(Point(29590, 26900), 8);
    connRef876797766->setSourceEndpoint(srcPt876797766);
    ConnEnd dstPt876797766(Point(29940, 26950), 8);
    connRef876797766->setDestEndpoint(dstPt876797766);
    connRef876797766->setRoutingType((ConnType)2);

    ConnRef *connRef134423590 = new ConnRef(router, 134423590);
    ConnEnd srcPt134423590(Point(29590, 27000), 8);
    connRef134423590->setSourceEndpoint(srcPt134423590);
    ConnEnd dstPt134423590(Point(29940, 27050), 8);
    connRef134423590->setDestEndpoint(dstPt134423590);
    connRef134423590->setRoutingType((ConnType)2);

    ConnRef *connRef872586669 = new ConnRef(router, 872586669);
    ConnEnd srcPt872586669(Point(29590, 27100), 8);
    connRef872586669->setSourceEndpoint(srcPt872586669);
    ConnEnd dstPt872586669(Point(29940, 27150), 8);
    connRef872586669->setDestEndpoint(dstPt872586669);
    connRef872586669->setRoutingType((ConnType)2);

    ConnRef *connRef23601612 = new ConnRef(router, 23601612);
    ConnEnd srcPt23601612(Point(29590, 27200), 8);
    connRef23601612->setSourceEndpoint(srcPt23601612);
    ConnEnd dstPt23601612(Point(29940, 27250), 8);
    connRef23601612->setDestEndpoint(dstPt23601612);
    connRef23601612->setRoutingType((ConnType)2);
//.........这里部分代码省略.........

 static void Get(const std::string& url, THandlerFunction handler, const std::string& name = "") { router.map("GET", url, handler, name); }; //<! Helper for mapping GET

/*! Map an URL.
If method is left empty, it will match any method. Name is also optional, but needed if you want to find it for making URLs 
*/
    static void Map(const std::string& method, const std::string& url, THandlerFunction handler, const std::string& name = "") { router.map(method, url, handler, name); };