paho.mqtt-sn.embedded-c/MQTTSNGateway/src/MQTTSNGWAggregateTopicTable.cpp

/**************************************************************************************
 * Copyright (c) 2018, Tomoaki Yamaguchi
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v1.0 which accompany this distribution.
 *
 * The Eclipse Public License is available at
 *    http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 *   http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *    Tomoaki Yamaguchi - initial API and implementation and/or initial documentation
 **************************************************************************************/
#include "MQTTSNGWAggregateTopicTable.h"
#include "MQTTSNGWClient.h"

/*=====================================
 Class ClientTopicElement
 =====================================*/
ClientTopicElement::ClientTopicElement(Client* client)
{
	_client = client;
}

ClientTopicElement::~ClientTopicElement()
{

}

Client* ClientTopicElement::getClient(void)
{
	return _client;
}

ClientTopicElement* ClientTopicElement::getNextClientElement(void)
{
	return _next;
}

/*=====================================
 Class AggregateTopicElement
 =====================================*/
AggregateTopicElement::AggregateTopicElement(void)
{

}

AggregateTopicElement::AggregateTopicElement(Topic* topic, Client* client)
{
	_topic = topic;
	ClientTopicElement* elm = new ClientTopicElement(client);
	if ( elm != nullptr )
	{
		_head = elm;
		_tail = elm;
	}
}

AggregateTopicElement::~AggregateTopicElement(void)
{
	_mutex.lock();
	if ( _head != nullptr )
	{
		ClientTopicElement* p = _tail;
		while ( p )
		{
			ClientTopicElement* pPrev = p;
			delete p;
			p = pPrev->_prev;
		}
		_head = _tail = nullptr;
	}
	_mutex.unlock();
}

ClientTopicElement* AggregateTopicElement::add(Client* client)
{
	ClientTopicElement* elm = new ClientTopicElement(client);
	if ( elm == nullptr )
	{
		return nullptr;
	}

	_mutex.lock();

	if ( _head == nullptr )
	{
		_head = elm;
		_tail = elm;
	}
	else
	{
		ClientTopicElement* p = find(client);
		if ( p == nullptr )
		{
			 p = _tail;
			_tail = elm;
			elm->_prev = p;
			p->_next = elm;
		}
		else
		{
			delete elm;
			elm = p;
		}
	}
	_mutex.unlock();
	return elm;
}

ClientTopicElement* AggregateTopicElement::find(Client* client)
{
	ClientTopicElement* p = _head;
	while ( p != nullptr )
	{
		if ( p->_client == client)
		{
			break;
		}
		p = p->_next;
	}
	return p;
}

ClientTopicElement* AggregateTopicElement::getFirstClientTopicElement(void)
{
	return _head;
}

ClientTopicElement* AggregateTopicElement::getNextClientTopicElement(ClientTopicElement* elmClient)
{
	return elmClient->_next;
}

void AggregateTopicElement::eraseClient(Client* client)
{
	_mutex.lock();

	ClientTopicElement* p = find(client);
	if ( p != nullptr )
	{
		if ( p->_prev == nullptr )    // head element
		{
			_head = p->_next;
			if ( p->_next == nullptr )   // head & only one
			{
				_tail = nullptr;
			}
			else
			{
				p->_next->_prev = nullptr;  // head & midle
			}
		}
		else if ( p->_next != nullptr )  // middle
		{
			p->_prev->_next = p->_next;
		}
		else    // tail
		{
			p->_prev->_next = nullptr;
			_tail = p->_prev;
		}
		delete p;
	}
	_mutex.unlock();
}

/*=====================================
 Class AggregateTopicTable
 ======================================*/

AggregateTopicTable::AggregateTopicTable()
{

}

AggregateTopicTable::~AggregateTopicTable()
{

}

AggregateTopicElement* AggregateTopicTable::add(Topic* topic, Client* client)
{
	AggregateTopicElement* elm = nullptr;
	_mutex.lock();
	elm = getAggregateTopicElement(topic);
	if ( elm != nullptr )
	{
		if ( elm->find(client) == nullptr )
		{
			elm->add(client);
		}
	}
	else
	{
		Topic* newTopic = topic->duplicate();
		elm = new AggregateTopicElement(newTopic, client);
		if ( _head == nullptr )
		{
			_head = elm;
			_tail = elm;
		}
		else
		{
			elm->_prev = _tail;
			_tail->_next = elm;
			_tail = elm;
		}
	}
	_mutex.unlock();
	return elm;
}

void AggregateTopicTable::erase(Topic* topic, Client* client)
{
	AggregateTopicElement* elm = nullptr;

	_mutex.lock();
	elm = getAggregateTopicElement(topic);

	if ( elm != nullptr )
	{
		elm->eraseClient(client);
	}
	if ( elm->_head == nullptr )
	{
		erase(elm);
	}
	_mutex.unlock();
	return;
}

void AggregateTopicTable::erase(AggregateTopicElement* elmTopic)
{
	if ( elmTopic != nullptr )
	{
		if ( elmTopic->_prev == nullptr )    // head element
		{
			_head = elmTopic->_next;
			if ( elmTopic->_next == nullptr )   // head & only one
			{
				_tail = nullptr;
			}
			else
			{
				elmTopic->_next->_prev = nullptr;  // head & midle
			}
		}
		else if ( elmTopic->_next != nullptr )  // middle
		{
			elmTopic->_prev->_next = elmTopic->_next;
		}
		else    // tail
		{
			elmTopic->_prev->_next = nullptr;
			_tail = elmTopic->_prev;
		}
		delete elmTopic;
	}
}

AggregateTopicElement* AggregateTopicTable::getAggregateTopicElement(Topic* topic)
{
	AggregateTopicElement* elm = _head;

	while( elm != nullptr )
	{
		if ( elm->_topic->isMatch(topic->_topicName) )
		{
			break;
		}
		elm = elm->_next;
	}
	return elm;
}

ClientTopicElement* AggregateTopicTable::getClientElement(Topic* topic)
{
	AggregateTopicElement* elm = getAggregateTopicElement(topic);
	if ( elm != nullptr )
	{
		return elm->_head;
	}
	else
	{
		return nullptr;
	}
}

void AggregateTopicTable::print(void)
{
	AggregateTopicElement* elm = _head;

	printf("Beginning of AggregateTopicTable\n");
	while( elm != nullptr )
	{
		printf("%s\n", elm->_topic->getTopicName()->c_str());

		ClientTopicElement* clElm = elm->getFirstClientTopicElement();
		Client* client = clElm->getClient();

		while ( client != nullptr )
		{
			printf("    %s\n", client->getClientId());
			clElm = clElm->getNextClientElement();
			if ( clElm != nullptr )
			{
				client = clElm->getClient();
			}
			else
			{
				client = nullptr;
			}
		}
		elm = elm->_next;
	}
	printf("End of AggregateTopicTable\n");
}