text:
/**
 * @file
 * Definition of a crossbar object.
 */

#include "base/misc.hh"
#include "base/trace.hh"
#include "debug/AddrRanges.hh"
#include "debug/CoherentXBar.hh"
#include "mem/coherent_xbar.hh"
#include "sim/system.hh"

CoherentXBar::CoherentXBar(const CoherentXBarParams *p)
    : BaseXBar(p), system(p->system), snoopFilter(p->snoop_filter),
      snoopResponseLatency(p->snoop_response_latency)
{
    // create the ports based on the size of the master and slave
    // vector ports, and the presence of the default port, the ports
    // are enumerated starting from zero
    for (int i = 0; i < p->port_master_connection_count; ++i) {
        std::string portName = csprintf("%s.master[%d]", name(), i);
        MasterPort* bp = new CoherentXBarMasterPort(portName, *this, i);
        masterPorts.push_back(bp);
        reqLayers.push_back(new ReqLayer(*bp, *this,
                                         csprintf(".reqLayer%d", i)));
        snoopLayers.push_back(new SnoopRespLayer(*bp, *this,
                                                 csprintf(".snoopLayer%d", i)));
    }

    // see if we have a default slave device connected and if so add
    // our corresponding master port
    if (p->port_default_connection_count) {
        defaultPortID = masterPorts.size();
        std::string portName = name() + ".default";
        MasterPort* bp = new CoherentXBarMasterPort(portName, *this,
                                                   defaultPortID);
        masterPorts.push_back(bp);
        reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d",
                                             defaultPortID)));
        snoopLayers.push_back(new SnoopRespLayer(*bp, *this,
                                                 csprintf(".snoopLayer%d",
                                                          defaultPortID)));
    }

    // create the slave ports, once again starting at zero
    for (int i = 0; i < p->port_slave_connection_count; ++i) {
        std::string portName = csprintf("%s.slave[%d]", name(), i);
        SlavePort* bp = new CoherentXBarSlavePort(portName, *this, i);
        slavePorts.push_back(bp);
        respLayers.push_back(new RespLayer(*bp, *this,
                                           csprintf(".respLayer%d", i)));
        snoopRespPorts.push_back(new SnoopRespPort(*bp, *this));
    }

    if (snoopFilter)
        snoopFilter->setSlavePorts(slavePorts);

    clearPortCache();
}

CoherentXBar::~CoherentXBar()
{
    for (auto l: reqLayers)
        delete l;
    for (auto l: respLayers)
        delete l;
    for (auto l: snoopLayers)
        delete l;
    for (auto p: snoopRespPorts)
        delete p;
}

void
CoherentXBar::init()
{
    // the base class is responsible for determining the block size
    BaseXBar::init();

    // iterate over our slave ports and determine which of our
    // neighbouring master ports are snooping and add them as snoopers
    for (const auto& p: slavePorts) {
        // check if the connected master port is snooping
        if (p->isSnooping()) {
            DPRINTF(AddrRanges, "Adding snooping master %s\n",
                    p->getMasterPort().name());
            snoopPorts.push_back(p);
        }
    }

    if (snoopPorts.empty())
        warn("CoherentXBar %s has no snooping ports attached!\n", name());
}

bool
CoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id)
{
    // determine the source port based on the id
    SlavePort *src_port = slavePorts[slave_port_id];

    // remember if the packet is an express snoop
    bool is_express_snoop = pkt->isExpressSnoop();
    bool is_inhibited = pkt->memInhibitAsserted();
    // for normal requests, going downstream, the express snoop flag
    // and the inhibited flag should always be the same
    assert(is_express_snoop == is_inhibited);

    // determine the destination based on the address
    PortID master_port_id = findPort(pkt->getAddr());

    // test if the crossbar should be considered occupied for the current
    // port, and exclude express snoops from the check
    if (!is_express_snoop && !reqLayers[master_port_id]->tryTiming(src_port)) {
        DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n",
                src_port->name(), pkt->cmdString(), pkt->getAddr());
        return false;
    }

    DPRINTF(CoherentXBar, "recvTimingReq: src %s %s expr %d 0x%x\n",
            src_port->name(), pkt->cmdString(), is_express_snoop,
            pkt->getAddr());

    // store size and command as they might be modified when
    // forwarding the packet
    unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
    unsigned int pkt_cmd = pkt->cmdToIndex();

    // store the old header delay so we can restore it if needed
    Tick old_header_delay = pkt->headerDelay;

    // a request sees the frontend and forward latency
    Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod();

    // set the packet header and payload delay
    calcPacketTiming(pkt, xbar_delay);

    // determine how long to be crossbar layer is busy
    Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;

    // uncacheable requests need never be snooped
    if (!pkt->req->isUncacheable() && !system->bypassCaches()) {
        // the packet is a memory-mapped request and should be
        // broadcasted to our snoopers but the source
        if (snoopFilter) {
            // check with the snoop filter where to forward this packet
            auto sf_res = snoopFilter->lookupRequest(pkt, *src_port);
            // If SnoopFilter is enabled, the total time required by a packet
            // to be delivered through the xbar has to be charged also with
            // to lookup latency of the snoop filter (sf_res.second).
            pkt->headerDelay += sf_res.second * clockPeriod();
            packetFinishTime += sf_res.second * clockPeriod();
            DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x"\
                    " SF size: %i lat: %i\n", src_port->name(),
                    pkt->cmdString(), pkt->getAddr(), sf_res.first.size(),
                    sf_res.second);
            forwardTiming(pkt, slave_port_id, sf_res.first);
        } else {
            forwardTiming(pkt, slave_port_id);
        }
    }

    // remember if the packet will generate a snoop response
    const bool expect_snoop_resp = !is_inhibited && pkt->memInhibitAsserted();
    const bool expect_response = pkt->needsResponse() &&
        !pkt->memInhibitAsserted();

    // Note: Cannot create a copy of the full packet, here.
    MemCmd orig_cmd(pkt->cmd);

    // since it is a normal request, attempt to send the packet
    bool success = masterPorts[master_port_id]->sendTimingReq(pkt);

    if (snoopFilter && !pkt->req->isUncacheable()
        && !system->bypassCaches()) {
        // The packet may already be overwritten by the sendTimingReq function.
        // The snoop filter needs to see the original request *and* the return
        // status of the send operation, so we need to recreate the original
        // request.  Atomic mode does not have the issue, as there the send
        // operation and the response happen instantaneously and don't need two
        // phase tracking.
        MemCmd tmp_cmd(pkt->cmd);
        pkt->cmd = orig_cmd;
        // Let the snoop filter know about the success of the send operation
        snoopFilter->updateRequest(pkt, *src_port, !success);
        pkt->cmd = tmp_cmd;
    }

    // check if we were successful in sending the packet onwards
    if (!success)  {
        // express snoops and inhibited packets should never be forced
        // to retry
        assert(!is_express_snoop);
        assert(!pkt->memInhibitAsserted());

        // restore the header delay
        pkt->headerDelay = old_header_delay;

        DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n",
                src_port->name(), pkt->cmdString(), pkt->getAddr());

        // update the layer state and schedule an idle event
        reqLayers[master_port_id]->failedTiming(src_port,
                                                clockEdge(Cycles(1)));
    } else {
        // express snoops currently bypass the crossbar state entirely
        if (!is_express_snoop) {
            // if this particular request will generate a snoop
            // response
            if (expect_snoop_resp) {
                // we should never have an exsiting request outstanding
                assert(outstandingSnoop.find(pkt->req) ==
                       outstandingSnoop.end());
                outstandingSnoop.insert(pkt->req);

                // basic sanity check on the outstanding snoops
                panic_if(outstandingSnoop.size() > 512,
                         "Outstanding snoop requests exceeded 512\n");
            }

            // remember where to route the normal response to
            if (expect_response || expect_snoop_resp) {
                assert(routeTo.find(pkt->req) == routeTo.end());
                routeTo[pkt->req] = slave_port_id;

                panic_if(routeTo.size() > 512,
                         "Routing table exceeds 512 packets\n");
            }

            // update the layer state and schedule an idle event
            reqLayers[master_port_id]->succeededTiming(packetFinishTime);
        }

        // stats updates only consider packets that were successfully sent
        pktCount[slave_port_id][master_port_id]++;
        pktSize[slave_port_id][master_port_id] += pkt_size;
        transDist[pkt_cmd]++;

        if (is_express_snoop)
            snoops++;
    }

    return success;
}

bool
CoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id)
{
    // determine the source port based on the id
    MasterPort *src_port = masterPorts[master_port_id];

    // determine the destination
    const auto route_lookup = routeTo.find(pkt->req);
    assert(route_lookup != routeTo.end());
    const PortID slave_port_id = route_lookup->second;
    assert(slave_port_id != InvalidPortID);
    assert(slave_port_id < respLayers.size());

    // test if the crossbar should be considered occupied for the
    // current port
    if (!respLayers[slave_port_id]->tryTiming(src_port)) {
        DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n",
                src_port->name(), pkt->cmdString(), pkt->getAddr());
        return false;
    }

    DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x\n",
            src_port->name(), pkt->cmdString(), pkt->getAddr());

    // store size and command as they might be modified when
    // forwarding the packet
    unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
    unsigned int pkt_cmd = pkt->cmdToIndex();

    // a response sees the response latency
    Tick xbar_delay = responseLatency * clockPeriod();

    // set the packet header and payload delay
    calcPacketTiming(pkt, xbar_delay);

    // determine how long to be crossbar layer is busy
    Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;

    if (snoopFilter && !pkt->req->isUncacheable() && !system->bypassCaches()) {
        // let the snoop filter inspect the response and update its state
        snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]);
    }

    // send the packet through the destination slave port
    bool success M5_VAR_USED = slavePorts[slave_port_id]->sendTimingResp(pkt);

    // currently it is illegal to block responses... can lead to
    // deadlock
    assert(success);

    // remove the request from the routing table
    routeTo.erase(route_lookup);

    respLayers[slave_port_id]->succeededTiming(packetFinishTime);

    // stats updates
    pktCount[slave_port_id][master_port_id]++;
    pktSize[slave_port_id][master_port_id] += pkt_size;
    transDist[pkt_cmd]++;

    return true;
}

void
CoherentXBar::recvTimingSnoopReq(PacketPtr pkt, PortID master_port_id)
{
    DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x\n",
            masterPorts[master_port_id]->name(), pkt->cmdString(),
            pkt->getAddr());

    // update stats here as we know the forwarding will succeed
    transDist[pkt->cmdToIndex()]++;
    snoops++;

    // we should only see express snoops from caches
    assert(pkt->isExpressSnoop());

    // remeber if the packet is inhibited so we can see if it changes
    const bool is_inhibited = pkt->memInhibitAsserted();

    if (snoopFilter) {
        // let the Snoop Filter work its magic and guide probing
        auto sf_res = snoopFilter->lookupSnoop(pkt);
        // No timing here: packetFinishTime += sf_res.second * clockPeriod();
        DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x"\
                " SF size: %i lat: %i\n", masterPorts[master_port_id]->name(),
                pkt->cmdString(), pkt->getAddr(), sf_res.first.size(),
                sf_res.second);

        // forward to all snoopers
        forwardTiming(pkt, InvalidPortID, sf_res.first);
    } else {
        forwardTiming(pkt, InvalidPortID);
    }

    // if we can expect a response, remember how to route it
    if (!is_inhibited && pkt->memInhibitAsserted()) {
        assert(routeTo.find(pkt->req) == routeTo.end());
        routeTo[pkt->req] = master_port_id;
    }

    // a snoop request came from a connected slave device (one of
    // our master ports), and if it is not coming from the slave
    // device responsible for the address range something is
    // wrong, hence there is nothing further to do as the packet
    // would be going back to where it came from
    assert(master_port_id == findPort(pkt->getAddr()));
}

bool
CoherentXBar::recvTimingSnoopResp(PacketPtr pkt, PortID slave_port_id)
{
    // determine the source port based on the id
    SlavePort* src_port = slavePorts[slave_port_id];

    // get the destination
    const auto route_lookup = routeTo.find(pkt->req);
    assert(route_lookup != routeTo.end());
    const PortID dest_port_id = route_lookup->second;
    assert(dest_port_id != InvalidPortID);

    // determine if the response is from a snoop request we
    // created as the result of a normal request (in which case it
    // should be in the outstandingSnoop), or if we merely forwarded
    // someone else's snoop request
    const bool forwardAsSnoop = outstandingSnoop.find(pkt->req) ==
        outstandingSnoop.end();

    // test if the crossbar should be considered occupied for the
    // current port, note that the check is bypassed if the response
    // is being passed on as a normal response since this is occupying
    // the response layer rather than the snoop response layer
    if (forwardAsSnoop) {
        assert(dest_port_id < snoopLayers.size());
        if (!snoopLayers[dest_port_id]->tryTiming(src_port)) {
            DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n",
                    src_port->name(), pkt->cmdString(), pkt->getAddr());
            return false;
        }
    } else {
        // get the master port that mirrors this slave port internally
        MasterPort* snoop_port = snoopRespPorts[slave_port_id];
        assert(dest_port_id < respLayers.size());
        if (!respLayers[dest_port_id]->tryTiming(snoop_port)) {
            DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n",
                    snoop_port->name(), pkt->cmdString(), pkt->getAddr());
            return false;
        }
    }

    DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x\n",
            src_port->name(), pkt->cmdString(), pkt->getAddr());

    // store size and command as they might be modified when
    // forwarding the packet
    unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
    unsigned int pkt_cmd = pkt->cmdToIndex();

    // responses are never express snoops
    assert(!pkt->isExpressSnoop());

    // a snoop response sees the snoop response latency, and if it is
    // forwarded as a normal response, the response latency
    Tick xbar_delay =
        (forwardAsSnoop ? snoopResponseLatency : responseLatency) *
        clockPeriod();

    // set the packet header and payload delay
    calcPacketTiming(pkt, xbar_delay);

    // determine how long to be crossbar layer is busy
    Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;

    // forward it either as a snoop response or a normal response
    if (forwardAsSnoop) {
        // this is a snoop response to a snoop request we forwarded,
        // e.g. coming from the L1 and going to the L2, and it should
        // be forwarded as a snoop response

        if (snoopFilter) {
            // update the probe filter so that it can properly track the line
            snoopFilter->updateSnoopForward(pkt, *slavePorts[slave_port_id],
                                            *masterPorts[dest_port_id]);
        }

        bool success M5_VAR_USED =
            masterPorts[dest_port_id]->sendTimingSnoopResp(pkt);
        pktCount[slave_port_id][dest_port_id]++;
        pktSize[slave_port_id][dest_port_id] += pkt_size;
        assert(success);

        snoopLayers[dest_port_id]->succeededTiming(packetFinishTime);
    } else {
        // we got a snoop response on one of our slave ports,
        // i.e. from a coherent master connected to the crossbar, and
        // since we created the snoop request as part of recvTiming,
        // this should now be a normal response again
        outstandingSnoop.erase(pkt->req);

        // this is a snoop response from a coherent master, hence it
        // should never go back to where the snoop response came from,
        // but instead to where the original request came from
        assert(slave_port_id != dest_port_id);

        if (snoopFilter) {
            // update the probe filter so that it can properly track the line
            snoopFilter->updateSnoopResponse(pkt, *slavePorts[slave_port_id],
                                    *slavePorts[dest_port_id]);
        }

        DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x"\
                " FWD RESP\n", src_port->name(), pkt->cmdString(),
                pkt->getAddr());

        // as a normal response, it should go back to a master through
        // one of our slave ports, at this point we are ignoring the
        // fact that the response layer could be busy and do not touch
        // its state
        bool success M5_VAR_USED =
            slavePorts[dest_port_id]->sendTimingResp(pkt);

        // @todo Put the response in an internal FIFO and pass it on
        // to the response layer from there

        // currently it is illegal to block responses... can lead
        // to deadlock
        assert(success);

        respLayers[dest_port_id]->succeededTiming(packetFinishTime);
    }

    // remove the request from the routing table
    routeTo.erase(route_lookup);

    // stats updates
    transDist[pkt_cmd]++;
    snoops++;

    return true;
}

void
CoherentXBar::forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id,
                           const std::vector<SlavePort*>& dests)
{
    DPRINTF(CoherentXBar, "%s for %s address %x size %d\n", __func__,
            pkt->cmdString(), pkt->getAddr(), pkt->getSize());

    // snoops should only happen if the system isn't bypassing caches
    assert(!system->bypassCaches());

    unsigned fanout = 0;

    for (const auto& p: dests) {
        // we could have gotten this request from a snooping master
        // (corresponding to our own slave port that is also in
        // snoopPorts) and should not send it back to where it came
        // from
        if (exclude_slave_port_id == InvalidPortID ||
            p->getId() != exclude_slave_port_id) {
            // cache is not allowed to refuse snoop
            p->sendTimingSnoopReq(pkt);
            fanout++;
        }
    }

    // Stats for fanout of this forward operation
    snoopFanout.sample(fanout);
}

void
CoherentXBar::recvReqRetry(PortID master_port_id)
{
    // responses and snoop responses never block on forwarding them,
    // so the retry will always be coming from a port to which we
    // tried to forward a request
    reqLayers[master_port_id]->recvRetry();
}

Tick
CoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id)
{
    DPRINTF(CoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n",
            slavePorts[slave_port_id]->name(), pkt->getAddr(),
            pkt->cmdString());

    unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
    unsigned int pkt_cmd = pkt->cmdToIndex();

    MemCmd snoop_response_cmd = MemCmd::InvalidCmd;
    Tick snoop_response_latency = 0;

    // uncacheable requests need never be snooped
    if (!pkt->req->isUncacheable() && !system->bypassCaches()) {
        // forward to all snoopers but the source
        std::pair<MemCmd, Tick> snoop_result;
        if (snoopFilter) {
            // check with the snoop filter where to forward this packet
            auto sf_res =
                snoopFilter->lookupRequest(pkt, *slavePorts[slave_port_id]);
            snoop_response_latency += sf_res.second * clockPeriod();
            DPRINTF(CoherentXBar, "%s: src %s %s 0x%x"\
                    " SF size: %i lat: %i\n", __func__,
                    slavePorts[slave_port_id]->name(), pkt->cmdString(),
                    pkt->getAddr(), sf_res.first.size(), sf_res.second);
            snoop_result = forwardAtomic(pkt, slave_port_id, InvalidPortID,
                                         sf_res.first);
        } else {
            snoop_result = forwardAtomic(pkt, slave_port_id);
        }
        snoop_response_cmd = snoop_result.first;
        snoop_response_latency += snoop_result.second;
    }

    // even if we had a snoop response, we must continue and also
    // perform the actual request at the destination
    PortID master_port_id = findPort(pkt->getAddr());

    // stats updates for the request
    pktCount[slave_port_id][master_port_id]++;
    pktSize[slave_port_id][master_port_id] += pkt_size;
    transDist[pkt_cmd]++;

    // forward the request to the appropriate destination
    Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt);

    // Lower levels have replied, tell the snoop filter
    if (snoopFilter && !pkt->req->isUncacheable() && !system->bypassCaches() &&
        pkt->isResponse()) {
        snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]);
    }

    // if we got a response from a snooper, restore it here
    if (snoop_response_cmd != MemCmd::InvalidCmd) {
        // no one else should have responded
        assert(!pkt->isResponse());
        pkt->cmd = snoop_response_cmd;
        response_latency = snoop_response_latency;
    }

    // add the response data
    if (pkt->isResponse()) {
        pkt_size = pkt->hasData() ? pkt->getSize() : 0;
        pkt_cmd = pkt->cmdToIndex();

        // stats updates
        pktCount[slave_port_id][master_port_id]++;
        pktSize[slave_port_id][master_port_id] += pkt_size;
        transDist[pkt_cmd]++;
    }

    // @todo: Not setting header time
    pkt->payloadDelay = response_latency;
    return response_latency;
}

Tick
CoherentXBar::recvAtomicSnoop(PacketPtr pkt, PortID master_port_id)
{
    DPRINTF(CoherentXBar, "recvAtomicSnoop: packet src %s addr 0x%x cmd %s\n",
            masterPorts[master_port_id]->name(), pkt->getAddr(),
            pkt->cmdString());

    // add the request snoop data
    snoops++;

    // forward to all snoopers
    std::pair<MemCmd, Tick> snoop_result;
    Tick snoop_response_latency = 0;
    if (snoopFilter) {
        auto sf_res = snoopFilter->lookupSnoop(pkt);
        snoop_response_latency += sf_res.second * clockPeriod();
        DPRINTF(CoherentXBar, "%s: src %s %s 0x%x SF size: %i lat: %i\n",
                __func__, masterPorts[master_port_id]->name(), pkt->cmdString(),
                pkt->getAddr(), sf_res.first.size(), sf_res.second);
        snoop_result = forwardAtomic(pkt, InvalidPortID, master_port_id,
                                     sf_res.first);
    } else {
        snoop_result = forwardAtomic(pkt, InvalidPortID);
    }
    MemCmd snoop_response_cmd = snoop_result.first;
    snoop_response_latency += snoop_result.second;

    if (snoop_response_cmd != MemCmd::InvalidCmd)
        pkt->cmd = snoop_response_cmd;

    // add the response snoop data
    if (pkt->isResponse()) {
        snoops++;
    }

    // @todo: Not setting header time
    pkt->payloadDelay = snoop_response_latency;
    return snoop_response_latency;
}

std::pair<MemCmd, Tick>
CoherentXBar::forwardAtomic(PacketPtr pkt, PortID exclude_slave_port_id,
                           PortID source_master_port_id,
                           const std::vector<SlavePort*>& dests)
{
    // the packet may be changed on snoops, record the original
    // command to enable us to restore it between snoops so that
    // additional snoops can take place properly
    MemCmd orig_cmd = pkt->cmd;
    MemCmd snoop_response_cmd = MemCmd::InvalidCmd;
    Tick snoop_response_latency = 0;

    // snoops should only happen if the system isn't bypassing caches
    assert(!system->bypassCaches());

    unsigned fanout = 0;

    for (const auto& p: dests) {
        // we could have gotten this request from a snooping master
        // (corresponding to our own slave port that is also in
        // snoopPorts) and should not send it back to where it came
        // from
        if (exclude_slave_port_id != InvalidPortID &&
            p->getId() == exclude_slave_port_id)
            continue;

        Tick latency = p->sendAtomicSnoop(pkt);
        fanout++;

        // in contrast to a functional access, we have to keep on
        // going as all snoopers must be updated even if we get a
        // response
        if (!pkt->isResponse())
            continue;

        // response from snoop agent
        assert(pkt->cmd != orig_cmd);
        assert(pkt->memInhibitAsserted());
        // should only happen once
        assert(snoop_response_cmd == MemCmd::InvalidCmd);
        // save response state
        snoop_response_cmd = pkt->cmd;
        snoop_response_latency = latency;

        if (snoopFilter) {
            // Handle responses by the snoopers and differentiate between
            // responses to requests from above and snoops from below
            if (source_master_port_id != InvalidPortID) {
                // Getting a response for a snoop from below
                assert(exclude_slave_port_id == InvalidPortID);
                snoopFilter->updateSnoopForward(pkt, *p,
                             *masterPorts[source_master_port_id]);
            } else {
                // Getting a response for a request from above
                assert(source_master_port_id == InvalidPortID);
                snoopFilter->updateSnoopResponse(pkt, *p,
                             *slavePorts[exclude_slave_port_id]);
            }
        }
        // restore original packet state for remaining snoopers
        pkt->cmd = orig_cmd;
    }

    // Stats for fanout
    snoopFanout.sample(fanout);

    // the packet is restored as part of the loop and any potential
    // snoop response is part of the returned pair
    return std::make_pair(snoop_response_cmd, snoop_response_latency);
}

void
CoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id)
{
    if (!pkt->isPrint()) {
        // don't do DPRINTFs on PrintReq as it clutters up the output
        DPRINTF(CoherentXBar,
                "recvFunctional: packet src %s addr 0x%x cmd %s\n",
                slavePorts[slave_port_id]->name(), pkt->getAddr(),
                pkt->cmdString());
    }

    // uncacheable requests need never be snooped
    if (!pkt->req->isUncacheable() && !system->bypassCaches()) {
        // forward to all snoopers but the source
        forwardFunctional(pkt, slave_port_id);
    }

    // there is no need to continue if the snooping has found what we
    // were looking for and the packet is already a response
    if (!pkt->isResponse()) {
        PortID dest_id = findPort(pkt->getAddr());

        masterPorts[dest_id]->sendFunctional(pkt);
    }
}

void
CoherentXBar::recvFunctionalSnoop(PacketPtr pkt, PortID master_port_id)
{
    if (!pkt->isPrint()) {
        // don't do DPRINTFs on PrintReq as it clutters up the output
        DPRINTF(CoherentXBar,
                "recvFunctionalSnoop: packet src %s addr 0x%x cmd %s\n",
                masterPorts[master_port_id]->name(), pkt->getAddr(),
                pkt->cmdString());
    }

    // forward to all snoopers
    forwardFunctional(pkt, InvalidPortID);
}

void
CoherentXBar::forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id)
{
    // snoops should only happen if the system isn't bypassing caches
    assert(!system->bypassCaches());

    for (const auto& p: snoopPorts) {
        // we could have gotten this request from a snooping master
        // (corresponding to our own slave port that is also in
        // snoopPorts) and should not send it back to where it came
        // from
        if (exclude_slave_port_id == InvalidPortID ||
            p->getId() != exclude_slave_port_id)
            p->sendFunctionalSnoop(pkt);

        // if we get a response we are done
        if (pkt->isResponse()) {
            break;
        }
    }
}

unsigned int
CoherentXBar::drain(DrainManager *dm)
{
    // sum up the individual layers
    unsigned int total = 0;
    for (auto l: reqLayers)
        total += l->drain(dm);
    for (auto l: respLayers)
        total += l->drain(dm);
    for (auto l: snoopLayers)
        total += l->drain(dm);
    return total;
}

void
CoherentXBar::regStats()
{
    // register the stats of the base class and our layers
    BaseXBar::regStats();
    for (auto l: reqLayers)
        l->regStats();
    for (auto l: respLayers)
        l->regStats();
    for (auto l: snoopLayers)
        l->regStats();

    snoops
        .name(name() + ".snoops")
        .desc("Total snoops (count)")
    ;

    snoopFanout
        .init(0, snoopPorts.size(), 1)
        .name(name() + ".snoop_fanout")
        .desc("Request fanout histogram")
    ;
}

CoherentXBar *
CoherentXBarParams::create()
{
    return new CoherentXBar(this);
}


text:
package org.wso2.developerstudio.eclipse.gmf.esb;

import org.eclipse.emf.ecore.EObject;

/**
 *
 * A representation of the model object 'Router Route'.
 *
 *
 *

 * The following features are supported:
 *

 *

 *
{@link org.wso2.developerstudio.eclipse.gmf.esb.RouterRoute#isBreakAfterRoute Break After Route}

 *
{@link org.wso2.developerstudio.eclipse.gmf.esb.RouterRoute#getRouteExpression Route Expression}

 *
{@link org.wso2.developerstudio.eclipse.gmf.esb.RouterRoute#getRoutePattern Route Pattern}

 *

 *
 * @see org.wso2.developerstudio.eclipse.gmf.esb.EsbPackage#getRouterRoute()
 * @model
 * @generated
 */
public interface RouterRoute extends EsbNode {
	/**
	 * Returns the value of the 'Break After Route' attribute.
	 *
	 *

	 * If the meaning of the 'Break After Route' attribute isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @return the value of the 'Break After Route' attribute.
	 * @see #setBreakAfterRoute(boolean)
	 * @see org.wso2.developerstudio.eclipse.gmf.esb.EsbPackage#getRouterRoute_BreakAfterRoute()
	 * @model
	 * @generated
	 */
	boolean isBreakAfterRoute();

	/**
	 * Sets the value of the '{@link org.wso2.developerstudio.eclipse.gmf.esb.RouterRoute#isBreakAfterRoute Break After Route}' attribute.
	 *
	 *
	 * @param value the new value of the 'Break After Route' attribute.
	 * @see #isBreakAfterRoute()
	 * @generated
	 */
	void setBreakAfterRoute(boolean value);

	/**
	 * Returns the value of the 'Route Expression' reference.
	 *
	 *

	 * If the meaning of the 'Route Expression' reference isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @return the value of the 'Route Expression' reference.
	 * @see #setRouteExpression(NamespacedProperty)
	 * @see org.wso2.developerstudio.eclipse.gmf.esb.EsbPackage#getRouterRoute_RouteExpression()
	 * @model
	 * @generated
	 */
	NamespacedProperty getRouteExpression();

	/**
	 * Sets the value of the '{@link org.wso2.developerstudio.eclipse.gmf.esb.RouterRoute#getRouteExpression Route Expression}' reference.
	 *
	 *
	 * @param value the new value of the 'Route Expression' reference.
	 * @see #getRouteExpression()
	 * @generated
	 */
	void setRouteExpression(NamespacedProperty value);

	/**
	 * Returns the value of the 'Route Pattern' attribute.
	 *
	 *

	 * If the meaning of the 'Route Pattern' attribute isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @return the value of the 'Route Pattern' attribute.
	 * @see #setRoutePattern(String)
	 * @see org.wso2.developerstudio.eclipse.gmf.esb.EsbPackage#getRouterRoute_RoutePattern()
	 * @model
	 * @generated
	 */
	String getRoutePattern();

	/**
	 * Sets the value of the '{@link org.wso2.developerstudio.eclipse.gmf.esb.RouterRoute#getRoutePattern Route Pattern}' attribute.
	 *
	 *
	 * @param value the new value of the 'Route Pattern' attribute.
	 * @see #getRoutePattern()
	 * @generated
	 */
	void setRoutePattern(String value);

} // RouterRoute

redpajama_set_name: RedPajamaGithub


text:
{% extends 'accounts/accounts_base.html' %}{% load bootstrap3 %}
{% load cms_tags staticfiles %}

{% block page_title %}Profile for {{ user.get_full_name }}{% endblock page_title %}

{% block title %}Profile{% endblock title %}

{% block css %}{{ block.super }}
<link rel="stylesheet" type="text/css" href="{% static 'js/vendor/chosen/chosen.min.css' %}" media="screen">
{% endblock css %}

{% block main_content %}{# TODO: change this to use tabs like project detail pages, Activity & Publications #}

      Activity

      Publications

    {% if tab == 'activity' %}
      {% bootstrap_messages %}
      <form class="form-inline" action="" method="get">
        {% bootstrap_field filter_form.content_type show_label=False %}
        <button class="btn btn-primary" type="submit">
          Filter
        </button>
      </form>

      {% include page_template %}
    {% endif %}

    {% if tab == 'publications' %}
      {% for publication in publications %}
        {% include 'bibliography/_reference.html' with obj=publication.reference %}
      {% empty %}
        {% if request.user == user %}

Please add your ORCID id to your profile so we can show your publications.

        {% else %}

Coming soon!

        {% endif %}
      {% endfor %}
    {% endif %}

{% endblock main_content %}

{% block js-footer %}{{ block.super }}

{% endblock js-footer %}


text:
<?php
namespace Concrete\Core\Permission\Access;

use Database;
use Concrete\Core\Permission\Key\Key as PermissionKey;

class ViewUserAttributesUserAccess extends UserAccess
{
    public function save($args = array())
    {
        parent::save();
        $db = Database::connection();
        $db->executeQuery('delete from UserPermissionViewAttributeAccessList where paID = ?', array($this->getPermissionAccessID()));
        $db->executeQuery('delete from UserPermissionViewAttributeAccessListCustom where paID = ?', array($this->getPermissionAccessID()));
        if (isset($args['viewAttributesIncluded']) && is_array($args['viewAttributesIncluded'])) {
            foreach ($args['viewAttributesIncluded'] as $peID => $permission) {
                $v = array($this->getPermissionAccessID(), $peID, $permission);
                $db->executeQuery('insert into UserPermissionViewAttributeAccessList (paID, peID, permission) values (?, ?, ?)', $v);
            }
        }

        if (isset($args['viewAttributesExcluded']) && is_array($args['viewAttributesExcluded'])) {
            foreach ($args['viewAttributesExcluded'] as $peID => $permission) {
                $v = array($this->getPermissionAccessID(), $peID, $permission);
                $db->executeQuery('insert into UserPermissionViewAttributeAccessList (paID, peID, permission) values (?, ?, ?)', $v);
            }
        }

        if (isset($args['akIDInclude']) && is_array($args['akIDInclude'])) {
            foreach ($args['akIDInclude'] as $peID => $akIDs) {
                foreach ($akIDs as $akID) {
                    $v = array($this->getPermissionAccessID(), $peID, $akID);
                    $db->executeQuery('insert into UserPermissionViewAttributeAccessListCustom (paID, peID, akID) values (?, ?, ?)', $v);
                }
            }
        }

        if (isset($args['akIDExclude']) && is_array($args['akIDExclude'])) {
            foreach ($args['akIDExclude'] as $peID => $akIDs) {
                foreach ($akIDs as $akID) {
                    $v = array($this->getPermissionAccessID(), $peID, $akID);
                    $db->executeQuery('insert into UserPermissionViewAttributeAccessListCustom (paID, peID, akID) values (?, ?, ?)', $v);
                }
            }
        }
    }

    public function duplicate($newPA = false)
    {
        $newPA = parent::duplicate($newPA);
        $db = Database::connection();
        $r = $db->executeQuery('select * from UserPermissionViewAttributeAccessList where paID = ?', array($this->getPermissionAccessID()));
        while ($row = $r->fetch()) {
            $v = array($row['peID'], $newPA->getPermissionAccessID(), $row['permission']);
            $db->executeQuery('insert into UserPermissionViewAttributeAccessList (peID, paID, permission) values (?, ?, ?)', $v);
        }
        $r = $db->executeQuery('select * from UserPermissionViewAttributeAccessListCustom where paID = ?', array($this->getPermissionAccessID()));
        while ($row = $r->fetch()) {
            $v = array($row['peID'], $newPA->getPermissionAccessID(), $row['akID']);
            $db->executeQuery('insert into UserPermissionViewAttributeAccessListCustom  (peID, paID, akID) values (?, ?, ?)', $v);
        }

        return $newPA;
    }

    public function getAccessListItems($accessType = PermissionKey::ACCESS_TYPE_INCLUDE, $filterEntities = array(), $checkCache = true)
    {
        $db = Database::connection();
        $list = parent::getAccessListItems($accessType, $filterEntities);
        foreach ($list as $l) {
            $pe = $l->getAccessEntityObject();
            if (isset($this->permissionObjectToCheck) && ($this->permissionObjectToCheck instanceof Page) && ($l->getAccessType() == PermissionKey::ACCESS_TYPE_INCLUDE)) {
                $permission = 'A';
            } else {
                $permission = $db->fetchColumn('select permission from UserPermissionViewAttributeAccessList where paID = ? and peID = ?', array($l->getPermissionAccessID(), $pe->getAccessEntityID()));
                if ($permission != 'N' && $permission != 'C') {
                    $permission = 'A';
                }
            }
            $l->setAttributesAllowedPermission($permission);
            if ($permission == 'C') {
                $akIDs = $db->GetCol('select akID from UserPermissionViewAttributeAccessListCustom where paID = ? and peID = ?', array($l->getPermissionAccessID(), $pe->getAccessEntityID()));
                $l->setAttributesAllowedArray($akIDs);
            }
        }

        return $list;
    }
}


text:
@interface YHFMDBHelperTests : XCTestCase

@end

@implementation YHFMDBHelperTests

- (YHContact *)contact {
    static int number = 0;
    number++;

    YHContact *contact = [[YHContact alloc] init];
    contact.name = [NSString stringWithFormat:@"name_%d", number];
    contact.age = number + 10;
    contact.married = number % 2;
    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
    [formatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];
    contact.birthday = [formatter stringFromDate:[NSDate date]];
    contact.height = 0.3 + (float)number * 0.1;
    contact.homeAddress = [NSString stringWithFormat:@"home_address_%d", number];
    contact.mobilePhone = [NSString stringWithFormat:@"1380000%d", (number + 1000)];
    return contact;
}

- (void)setUp {
    [super setUp];
    [YHFMDBUtils createTable:[YHContact class]];
}

- (void)tearDown {
    [super tearDown];
}

- (void)test00_Save {
    for (int i = 0; i < 20; i++) {
        YHContact *contact = [self contact];

        BOOL flag = [YHFMDBUtils save:contact];

        XCTAssertTrue(flag);
    }
}

- (void)test10_SearchAll {
    NSArray *contacts = [YHFMDBUtils search:[YHContact class]];

    XCTAssertTrue(contacts.count > 0);
}

// ==
- (void)test11_SearchWhereEq {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.name).eq(@"");
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count == 0);
}

// !=
- (void)test12_SearchWhereNot_Eq {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.married).not_eq (@YES);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// >
- (void)test13_SearchWhereGt {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.age).gt(@100);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count == 0);
}

// >=
- (void)test14_SearchWhereGt_Eq {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.age).gt_and_eq(@11);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// <
- (void)test15_SearchWhereLt {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.height).lt(@0.0f);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count == 0);
}

// <=
- (void)test16_SearchWhereLt_Eq {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.height).lt_and_eq(@1.5f);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// between and
- (void)test19_SearchWhereBtw_and {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.age).btw_and(@[ @10, @20 ]);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// not between and
- (void)test20_SearchWhereNot_btw_and {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.age).not_btw_and(@[ @10, @20 ]);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// is not null
- (void)test21_SearchWhereIs_not_null {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.height).is_not_null();
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// is null
- (void)test22_SearchWhereIs_null {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.height).is_null();
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count <= 0);
}

// like
- (void)test23_SearchWhereLk {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.name).lk(@"name");
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// not like
- (void)test24_SearchWhereNot_lk {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.name).not_lk(@"name");
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count <= 0);
}

// in
- (void)test25_SearchWhereIn {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.name).in(@[ @"name_2", @"name_4" ]);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

// not in
- (void)test26_SearchWhereNot_in {
    YHContact *contact = [[YHContact alloc] init];

    NSString *condtion = @key(contact.name).not_in(@[ @"name_2", @"name_4" ]);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion];

    XCTAssertTrue(contacts.count > 0);
}

- (void)test30_SearchOrderBy {
    YHContact *contact = [[YHContact alloc] init];

    NSString *orderBy = order_by(@key(contact.age), @key(contact.name), nil).asc();
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:nil orderBy:orderBy];
    XCTAssertTrue(contacts.count > 0);
}

- (void)test31_SearchLimit {
    NSString *limitOffset = limit(@5).offset(@5);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:nil orderBy:nil limit:limitOffset];
    XCTAssertTrue(contacts.count > 0);
}

- (void)test32_SearchWhere_OrderBy_Limit {
    YHContact *contact = [[YHContact alloc] init];
    NSString *condtion = @key(contact.height).lt_and_eq(@1.5f).OR(@key(contact.age).eq(@16));
    NSString *orderBy = order_by(@key(contact.age), @key(contact.name), nil).desc();
    NSString *limitOffset = limit(@5).offset(@5);
    NSArray *contacts = [YHFMDBUtils search:[YHContact class] where:condtion orderBy:orderBy limit:limitOffset];
    XCTAssertTrue(contacts.count > 0);
}

- (void)test41_Count {
    int count = [YHFMDBUtils count:[YHContact class]];
    XCTAssertTrue(count > 1);
}

- (void)test99_RemoveAll {
    //    BOOL flag = [YHFMDBUtils removeAll:[YHContact class]];
    //    XCTAssertTrue(flag);
}
@end


text:
import ts from 'typescript';
import {ErrorCode, ngErrorCode} from '../../src/ngtsc/diagnostics';
import {runInEachFileSystem} from '../../src/ngtsc/file_system/testing';
import {getSourceCodeForDiagnostic, loadStandardTestFiles} from '../../src/ngtsc/testing';

import {NgtscTestEnvironment} from './env';

const testFiles = loadStandardTestFiles({fakeCore: true, fakeCommon: true});

runInEachFileSystem(() => {
  describe('ngtsc extended template checks', () => {
    let env!: NgtscTestEnvironment;

    beforeEach(() => {
      env = NgtscTestEnvironment.setup(testFiles);
      env.tsconfig({_extendedTemplateDiagnostics: true, strictTemplates: true});
    });

    it('should produce invalid banana in box warning', () => {
      env.write('test.ts', `
              import {Component} from '@angular/core';
              @Component({
                selector: 'test',
                template: '

',
              })
              class TestCmp {
                bar: string = "text";
              }
            `);

      const diags = env.driveDiagnostics();
      expect(diags.length).toBe(1);
      expect(diags[0].category).toBe(ts.DiagnosticCategory.Warning);
      expect(diags[0].code).toBe(ngErrorCode(ErrorCode.INVALID_BANANA_IN_BOX));
      expect(getSourceCodeForDiagnostic(diags[0])).toBe('([notARealThing])="bar"');
    });

    it('should produce invalid banana in box warning with external html file', () => {
      env.write('test.ts', `
              import {Component} from '@angular/core';
              @Component({
                selector: 'test',
                templateUrl: './test.html',
              })
              class TestCmp {
                bar: string = "text";
              }
            `);

      env.write('test.html', `

            `);

      const diags = env.driveDiagnostics();
      expect(diags.length).toBe(1);
      expect(diags[0].category).toBe(ts.DiagnosticCategory.Warning);
      expect(diags[0].code).toBe(ngErrorCode(ErrorCode.INVALID_BANANA_IN_BOX));
      expect(getSourceCodeForDiagnostic(diags[0])).toBe('([notARealThing])="bar"');
    });

    it('should not produce extended diagnostics if flag is disabled', () => {
      env.tsconfig({_extendedTemplateDiagnostics: false});
      env.write('test.ts', `
              import {Component} from '@angular/core';
              @Component({
                selector: 'test',
                template: '

',
              })
              class TestCmp {
                bar: string = "text";
              }
            `);

      const diags = env.driveDiagnostics();
      expect(diags.length).toBe(0);
    });

    it('should throw error if _extendedTemplateDiagnostics option is enabled and strictTemplates disabled',
       () => {
         env.tsconfig({_extendedTemplateDiagnostics: true, strictTemplates: false});
         env.write('test.ts', `
              import {Component} from '@angular/core';
              @Component({
                selector: 'test',
                template: '

',
              })
              class TestCmp {
                bar: string = "text";
              }
            `);

         const diags = env.driveDiagnostics();
         expect(diags.length).toBe(1);
         expect(diags[0].messageText)
             .toMatch(
                 /Error: The '_extendedTemplateDiagnostics' option requires 'strictTemplates' to also be enabled./);
       });

    it(`should produce nullish coalescing not nullable warning`, () => {
      env.write('test.ts', `
              import {Component} from '@angular/core';
              @Component({
                selector: 'test',
                template: '{{ bar ?? "foo" }}',
              })
              export class TestCmp {
                bar: string = "text";
              }
            `);

      const diags = env.driveDiagnostics();
      expect(diags.length).toBe(1);
      expect(diags[0].category).toBe(ts.DiagnosticCategory.Warning);
      expect(diags[0].code).toBe(ngErrorCode(ErrorCode.NULLISH_COALESCING_NOT_NULLABLE));
      expect(getSourceCodeForDiagnostic(diags[0])).toBe('bar ?? "foo"');
    });

    it(`should not produce nullish coalescing not nullable warning with strictNullChecks disabled`,
       () => {
         env.tsconfig(
             {_extendedTemplateDiagnostics: true, strictTemplates: true, strictNullChecks: false});
         env.write('test.ts', `
              import {Component} from '@angular/core';
              @Component({
                selector: 'test',
                template: '{{ bar ?? "foo" }}',
              })
              export class TestCmp {
                bar: string = undefined;
              }
            `);

         const diags = env.driveDiagnostics();
         expect(diags.length).toBe(0);
       });
  });
});


text:
using System.IO;
using System.IO.Compression;
using System.Text;

public static partial class Extensions
{
    /// <summary>
    ///     Extracts all the files in the specified zip archive to a directory on the file system
    /// </summary>
    /// <param name="this">The @this to act on.</param>
    /// <param name="destinationDirectoryName">
    ///     The path to the directory in which to place the
    ///     extracted files, specified as a relative or absolute path. A relative path is interpreted as
    ///     relative to the current working directory.
    /// </param>
    public static void ExtractZipFileToDirectory(this FileInfo @this, string destinationDirectoryName)
    {
        ZipFile.ExtractToDirectory(@this.FullName, destinationDirectoryName);
    }

    /// <summary>
    ///     Extracts all the files in the specified zip archive to a directory on the file system and uses the specified
    ///     character encoding for entry names.
    /// </summary>
    /// <param name="this">The path to the archive that is to be extracted.</param>
    /// <param name="destinationDirectoryName">
    ///     The path to the directory in which to place the extracted files, specified as a
    ///     relative or absolute path. A relative path is interpreted as relative to the current working directory.
    /// </param>
    /// <param name="entryNameEncoding">
    ///     The encoding to use when reading or writing entry names in this archive. Specify a
    ///     value for this parameter only when an encoding is required for interoperability with zip archive tools and
    ///     libraries that do not support UTF-8 encoding for entry names.
    /// </param>
    public static void ExtractZipFileToDirectory(this FileInfo @this, string destinationDirectoryName, Encoding entryNameEncoding)
    {
        ZipFile.ExtractToDirectory(@this.FullName, destinationDirectoryName, entryNameEncoding);
    }

    /// <summary>Extracts all the files in the specified zip archive to a directory on the file system.</summary>
    /// <param name="this">The @this to act on.</param>
    /// <param name="destinationDirectory">Pathname of the destination directory.</param>
    public static void ExtractZipFileToDirectory(this FileInfo @this, DirectoryInfo destinationDirectory)
    {
        ZipFile.ExtractToDirectory(@this.FullName, destinationDirectory.FullName);
    }

    /// <summary>
    ///     Extracts all the files in the specified zip archive to a directory on the file system
    ///     and uses the specified character encoding for entry names.
    /// </summary>
    /// <param name="this">The @this to act on.</param>
    /// <param name="destinationDirectory">Pathname of the destination directory.</param>
    /// <param name="entryNameEncoding">
    ///     The encoding to use when reading or writing entry names in
    ///     this archive. Specify a value for this parameter only when an encoding is required for
    ///     interoperability with zip archive tools and libraries that do not support UTF-8 encoding for
    ///     entry names.
    /// </param>
    public static void ExtractZipFileToDirectory(this FileInfo @this, DirectoryInfo destinationDirectory, Encoding entryNameEncoding)
    {
        ZipFile.ExtractToDirectory(@this.FullName, destinationDirectory.FullName, entryNameEncoding);
    }
}
#endif


text:
<?php

namespace PHPExiftool\Driver\Tag\Canon;

use JMS\Serializer\Annotation\ExclusionPolicy;
use PHPExiftool\Driver\AbstractTag;

/**
 * @ExclusionPolicy("all")
 */
class CRWParam extends AbstractTag
{

    protected $Id = 16386;

    protected $Name = 'CRWParam';

    protected $FullName = 'Canon::Main';

    protected $GroupName = 'Canon';

    protected $g0 = 'MakerNotes';

    protected $g1 = 'Canon';

    protected $g2 = 'Camera';

    protected $Type = 'undef';

    protected $Writable = false;

    protected $Description = 'CRW Param';

    protected $flag_Binary = true;

    protected $flag_Permanent = true;

}


text:
using Foundation;
using System.CodeDom.Compiler;

namespace OneSignal.Xamarin.Sample.iOS
{
	[Register ("ViewController")]
	partial class ViewController
	{
		[Outlet]
		UIKit.UITextField OutcomeKey { get; set; }

		[Outlet]
		UIKit.UITextField OutcomeValue { get; set; }

		[Outlet]
		UIKit.UITextField OutcomeValueKey { get; set; }

		[Outlet]
		[GeneratedCode ("iOS Designer", "1.0")]
		UIKit.UISegmentedControl PrivacyConsentControl { get; set; }

		[Outlet]
		UIKit.UITextField UniqueOutcomeKey { get; set; }

		[Action ("Button_TouchUpInside:")]
		partial void Button_TouchUpInside (UIKit.UIButton sender);

		[Action ("ConsentChanged:")]
		partial void ConsentChanged (UIKit.UISegmentedControl sender);

		[Action ("ExternalIdChanged:")]
		partial void ExternalIdChanged (UIKit.UITextField sender);

		[Action ("RegisterForPush:")]
		partial void RegisterForPush (UIKit.UIButton sender);

		[Action ("RemoveExternalUserId:")]
		partial void RemoveExternalUserId (UIKit.UIButton sender);

		[Action ("SendOutcome:")]
		partial void SendOutcome (UIKit.UIButton sender);

		[Action ("SendOutcomeWithValue:")]
		partial void SendOutcomeWithValue (UIKit.UIButton sender);

		[Action ("SendUniqueOutcome:")]
		partial void SendUniqueOutcome (UIKit.UIButton sender);

		[Action ("SetExternalUserId:")]
		partial void SetExternalUserId (UIKit.UIButton sender);

		void ReleaseDesignerOutlets ()
		{
			if (OutcomeKey != null) {
				OutcomeKey.Dispose ();
				OutcomeKey = null;
			}

			if (OutcomeValue != null) {
				OutcomeValue.Dispose ();
				OutcomeValue = null;
			}

			if (OutcomeValueKey != null) {
				OutcomeValueKey.Dispose ();
				OutcomeValueKey = null;
			}

			if (UniqueOutcomeKey != null) {
				UniqueOutcomeKey.Dispose ();
				UniqueOutcomeKey = null;
			}

			if (PrivacyConsentControl != null) {
				PrivacyConsentControl.Dispose ();
				PrivacyConsentControl = null;
			}
		}
	}
}


text:
<?xml version="1.0"?>
<project
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>planout4j-api</artifactId>
    <packaging>jar</packaging>
    <parent>
        <groupId>com.glassdoor.planout4j</groupId>
        <artifactId>planout4j-parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../</relativePath>
    </parent>

    <name>planout4j api</name>
    <description>PlanOut for Java main API</description>

    <dependencies>

		<dependency>
            <groupId>${project.groupId}</groupId>
            <artifactId>planout4j-core</artifactId>
        </dependency>
        <dependency>
            <groupId>${project.groupId}</groupId>
            <artifactId>planout4j-config</artifactId>
        </dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
            <optional>true</optional>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<scope>test</scope>
		</dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-math</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>


text:
define([
    '../lang/toString',
    '../object/get'
], function(toString, get) {

    var stache = /\{\{([^\}]+)\}\}/g; //mustache-like

    /**
     * String interpolation
     */
    function interpolate(template, replacements, syntax){
        template = toString(template);
        var replaceFn = function(match, prop){
            return toString( get(replacements, prop) );
        };
        return template.replace(syntax || stache, replaceFn);
    }

    return interpolate;

});


text:
require 'net/http'
require 'net/https'
require 'uri'
require 'multi_json'
require 'hashie'

require 'seesaw/client/users'
require 'seesaw/client/decisions'
require 'seesaw/client/slugs'
require 'seesaw/client/timelines'
require 'seesaw/client/choices'
require 'seesaw/client/votes'

module Seesaw
  # API client for interacting with the Seesaw API
  class Client
    include Seesaw::Client::Decisions
    include Seesaw::Client::Users
    include Seesaw::Client::Slugs
    include Seesaw::Client::Timelines
    include Seesaw::Client::Choices
    include Seesaw::Client::Votes

    attr_reader :access_token
    attr_reader :api_scheme
    attr_reader :api_host
    attr_reader :api_version

    # Initialize a new client.
    #
    # @param options [Hash] optionally specify `:access_token`, `:api_scheme`, `:api_host`, `:api_version`, or `:client_token`
    def initialize(options = {})
      options = { access_token: options } if options.is_a? String

      @access_token = options[:access_token] if options[:access_token]
      @api_scheme = (options[:api_scheme] or 'https')
      @api_host = (options[:api_host] or 'api.seesaw.co')
      @api_version = (options[:api_version] or 1)
      @client_token = options[:client_token] if options[:client_token]
    end

    # API base URL.
    #
    # @return [String] API base URL
    def base_url
      "#{@api_scheme}://#{@api_host}/v#{@api_version}/"
    end

    # Is the client has an access token.
    #
    # @return [Boolean] true if it is using one and false if it is not
    def authenticated?
      @access_token != nil and @access_token.length > 0
    end

    # Is the client using SSL.
    #
    # @return [Boolean] true if it is using SSL and false if it is not
    def ssl?
      @api_scheme == 'https'
    end

  private

    def http
      return @http if @http

      uri = URI.parse(self.base_url)
      @http = Net::HTTP.new(uri.host, uri.port)
      @http.use_ssl = self.ssl?
      @http
    end

    def request(method, path, params = nil)
      # Build request
      request = build_request(method, URI.parse("#{self.base_url}#{path}"))

      # Add headers
      request['Authorization'] = "Bearer #{self.access_token}" if authenticated?
      request['X-Seesaw-Client-Token'] = @client_token if @client_token
      request['Content-Type'] = 'application/json'

      # Add params as JSON if they exist
      request.body = MultiJson.dump(params) if method == :post and params

      # Request
      response = http.request(request)

      # Check for errors
      handle_error(response)

      # Return the raw response object
      response
    end

    def build_request(method, uri)
      case method
        when :get
          Net::HTTP::Get.new(uri.request_uri)
        when :post
          Net::HTTP::Post.new(uri.request_uri)
        when :put
          Net::HTTP::Put.new(uri.request_uri)
        when :delete
          Net::HTTP::Delete.new(uri.request_uri)
      end
    end

    def handle_error(response)
      # Find error or return
      return unless error = Seesaw::ERROR_MAP[response.code.to_i]

      # Try to add a useful message
      message = nil
      begin
        message = MultiJson.load(response.body)['error_description']
      rescue MultiJson::DecodeError => e
      end

      # Raise error
      raise error.new(message)
    end

    def json_request(*args)
      # Preform request
      response = request(*args)

      # Parse JSON
      object = MultiJson.load(response.body)

      # Hash
      return Hashie::Mash.new(object) if object.is_a? Hash

      # Array
      return object.map { |h| Hashie::Mash.new(h) } if object.is_a? Array

      # Fallback incase it's not a hash or array
      object
    end

    def boolean_from_response(*args)
      response = request(*args)
      (200..299).include? response.code.to_i
    end

    [:get, :post, :put, :delete].each do |method|
      define_method method do |*args|
        json_request(method, *args)
      end
    end
  end
end


text:
<?php

/**
 * This class allows multiple concurrent connections to the same Cuke4php port.  Each connection forks a process that
 * loads the same feature files and then runs the step definitions.  This is useful for cases where the Cuke4php server
 * is deployed to a remote machine and multiple automation scripts are simultaneously connecting to the server.
 *
 * Uses the PEAR Net_Server package
 **/

require_once "Cuke4Php.php";
require_once "Net/Server.php";
require_once "Net/Server/Handler.php";

class Cuke4PhpForkingServer extends Net_Server_Handler
{
	private $cuke4php;

	function __construct($_sFeaturePath, $_iPort) {
		$this->cuke4php = new Cuke4Php($_sFeaturePath, $_iPort);
	}

	function onReceiveData($iClientId = 0, $data = "") {
		$output = json_encode($this->cuke4php->process($data)) . "\n";
		$this->_server->sendData($iClientId, $output);
	}

	function onClose($iClientId) {
		// Do nothing
	}
}

?>