Ejemplo n.º 1
0
    void handleGetNodeInfoResponse(const ServiceCallResult<protocol::GetNodeInfo>& result)
    {
        Entry& entry = getEntry(result.getCallID().server_node_id);

        if (result.isSuccessful())
        {
            /*
             * Updating the uptime here allows to properly handle a corner case where the service response arrives
             * after the device has restarted and published its new NodeStatus (although it's unlikely to happen).
             */
            entry.uptime_sec = result.getResponse().status.uptime_sec;
            entry.request_needed = false;
            listeners_.forEach(NodeInfoRetrievedHandlerCaller(result.getCallID().server_node_id,
                                                              result.getResponse()));
        }
        else
        {
            if (num_attempts_ != UnlimitedRequestAttempts)
            {
                entry.num_attempts_made++;
                if (entry.num_attempts_made >= num_attempts_)
                {
                    entry.request_needed = false;
                    listeners_.forEach(GenericHandlerCaller<NodeID>(&INodeInfoListener::handleNodeInfoUnavailable,
                                                                    result.getCallID().server_node_id));
                }
            }
        }
    }
Ejemplo n.º 2
0
void combine(const Multiset& ms1, const Multiset& ms2, Multiset& result)
{
	result = ms1;
	for (int k = 0; k < ms2.uniqueSize(); k++) //loop through ms2 and insert into result
    {
		ItemType x;
        int n = ms2.get(k, x);
		for (int count = n; count > 0; count--) //insert all iterations of value
			result.insert(x);
    }
}
Ejemplo n.º 3
0
    virtual void handleNodeStatusChange(const NodeStatusChangeEvent& event)
    {
        const bool was_offline = !event.old_status.known ||
                                 (event.old_status.status_code == protocol::NodeStatus::STATUS_OFFLINE);

        const bool offline_now = !event.status.known ||
                                 (event.status.status_code == protocol::NodeStatus::STATUS_OFFLINE);

        if (was_offline || offline_now)
        {
            Entry& entry = getEntry(event.node_id);

            entry.request_needed = !offline_now;
            entry.num_attempts_made = 0;

            UAVCAN_TRACE("NodeInfoRetriever", "Offline status change: node ID %d, request needed: %d",
                         int(event.node_id.get()), int(entry.request_needed));

            if (entry.request_needed)
            {
                startTimerIfNotRunning();
            }
        }

        listeners_.forEach(
            GenericHandlerCaller<const NodeStatusChangeEvent&>(&INodeInfoListener::handleNodeStatusChange, event));
    }
Ejemplo n.º 4
0
void subtract(const Multiset& ms1, const Multiset& ms2, Multiset& result)
{
	if (&ms2 == &result) //If ms2 and result are the same object, then modifications to result change ms2, so a copy of ms2 has to be made
	{
		Multiset temp = ms2;
		result = ms1;
		//temp and result are NOT the same object, so temp remains the same for each iteration of the loop
		for (int i = 0; i < temp.uniqueSize(); i++)
		{
			ItemType item;
			int count = temp.get(i, item);
			for (int j = 0; j < count; j++)
				result.erase(item);
		}
	}
	else //ms2 and result are NOT the same object, so ms2 remains the same for each iteration of the loop
	{
		result = ms1;
		//If ms1 and result are the same object, nothing happens
		for (int i = 0; i < ms2.uniqueSize(); i++)
		{
			ItemType item;
			int count = ms2.get(i, item);
			for (int j = 0; j < count; j++)
				result.erase(item);
		}
	}
}
Ejemplo n.º 5
0
void subtract(const Multiset& ms1, const Multiset& ms2, Multiset& result)
{
	//make sure result is empty
	if (result.size() != 0)
	{
		Multiset temp;
		result = temp;
	}

	for (int m1 = 0; m1 < ms1.uniqueSize(); m1++)
	{
		ItemType m1_val;
		int n1 = ms1.get(m1, m1_val);
		for (int m2 = 0; m2 < ms2.uniqueSize(); m2++)
		{
			ItemType m2_val;
			int n2 = ms2.get(m2, m2_val);

			if (m1_val == m2_val && n1 > n2)
			{
				for (int count = n1-n2; count > 0; count--) //insert n1-n2 number of iterations
					result.insert(m1_val);
			}
		}
	}
}
Ejemplo n.º 6
0
void test()
{
    Multiset ulms;
    assert(ulms.insert(20));
    assert(ulms.insert(10));
    assert(ulms.insert(20));
    assert(ulms.insert(30));
    assert(ulms.insert(20));
    assert(ulms.insert(10));
    assert(ulms.size() == 6  &&  ulms.uniqueSize() == 3);
    assert(ulms.count(10) == 2);
    assert(ulms.count(20) == 3);
    assert(ulms.count(30) == 1);
    assert(ulms.count(40) == 0);
}
Ejemplo n.º 7
0
void combine(const Multiset& ms1, const Multiset& ms2, Multiset& result)
{
	bool addFirst = false; //addFirst indicates whether the contents of ms1 should be added to result
	bool addSecond = false; //addSecond does the same, but for ms2

	if (&ms1 == &result) //As result is ms1, only need to add ms2 to result to combine the two
		addSecond = true;
	else if (&ms2 == &result) //As result is ms2, only need to add ms1 to result to combine the two
		addFirst = true;
	else //Empty out result, as it may have contained something prior to this
	{
		int size = result.uniqueSize();
		for (int i = 0; i < size; i++)
		{
			ItemType item;
			result.get(0, item);
			result.eraseAll(item);
		}
		addFirst = true;
		addSecond = true;
	}

	if (addFirst) //ms1 and result are NOT the same object, so ms1.uniqueSize() remains the same for each iteration of the loop
	{
		for (int j = 0; j < ms1.uniqueSize(); j++)
		{
			ItemType item;
			int count = ms1.get(j, item);
			for (int k = 0; k < count; k++)
				result.insert(item);
		}
	}
	if (addSecond) //ms2 and result are NOT the same object, so ms2.uniqueSize() remains the same for each iteration of the loop
	{
		for (int j = 0; j < ms2.uniqueSize(); j++)
		{
			ItemType item;
			int count = ms2.get(j, item);
			for (int k = 0; k < count; k++)
				result.insert(item);
		}
	}
}
Ejemplo n.º 8
0
int main()
{
	Multiset<int> mi;
	mi.insert(7);  // OK
	Multiset<string> ms;
	ms.insert("http://www.symantec.com");  // OK
	Multiset<URL> mu;
	mu.insert(URL("http://www.symantec.com"));  // error!
}
Ejemplo n.º 9
0
    virtual void handleNodeStatusMessage(const ReceivedDataStructure<protocol::NodeStatus>& msg)
    {
        Entry& entry = getEntry(msg.getSrcNodeID());

        if (msg.uptime_sec < entry.uptime_sec)
        {
            entry.request_needed = true;
            entry.num_attempts_made = 0;

            startTimerIfNotRunning();
        }
        entry.uptime_sec = msg.uptime_sec;
        entry.updated_since_last_attempt = true;

        listeners_.forEach(GenericHandlerCaller<const ReceivedDataStructure<protocol::NodeStatus>&>(
            &INodeInfoListener::handleNodeStatusMessage, msg));
    }
Ejemplo n.º 10
0
int main(void)
{
	Multiset ms;
	ms.insert("fennel");
	ms.insert("fennel");
	ms.insert("fenugreek");
	ms.insert("fennel");
	for (int k = 0; k < ms.uniqueSize(); k++)
	{
		string x;
		int n = ms.get(k, x);
		cout << x << " occurs " << n << " times." << endl;
	}
}
Ejemplo n.º 11
0
inline void test_multiset_insert(Multiset c)
{
    using phx::arg_names::arg1;
    using phx::arg_names::arg2;
    using phx::arg_names::arg3;

    typename Multiset::value_type const value = *c.begin();
    typename Multiset::iterator c_begin = c.begin();
    std::size_t old_size = c.size();
    // wrapper for
    // iterator insert(iterator where, const value_type& val);
    typename Multiset::iterator it =
        phx::insert(arg1, arg2, arg3)(c, c_begin, value);

    if (test(*it != value || c.size() != old_size + 1)) {
        cerr << "Failed " << typeid(Multiset).name()
       << " test_multiset_insert 1\n";
        return;
    }

    // wrapper for
    // iterator insert(const value_type& val);
    typename Multiset::value_type const value2(1400);
    it = phx::insert(arg1, arg2)(c, value2);
    if (test(it == c.end())) {
        cerr << "Failed " << typeid(Multiset).name()
       << " test_multiset_insert 2\n";
        return;
    }

    // wrapper for
    // template<class InIt>
    // void insert(InIt first, InIt last);
    Multiset const const_c = build_assoc<Multiset>();
    typename Multiset::size_type size = c.size();
    phx::insert(arg1, const_c.begin(), const_c.end())(c);
    if (test(c.size() != size + const_c.size())) {
        cerr << "Failed " << typeid(Multiset).name()
       << " test_multiset_insert 3\n";
        return;
    }
}