MuditaOS/module-apps/DatabaseModel.hpp

/*
 * @file DatabaseModel.hpp
 * @author Robert Borzecki (robert.borzecki@mudita.com)
 * @date 8 sie 2019
 * @brief
 * @copyright Copyright (C) 2019 mudita.com
 * @details This class is a template to create specialized instances of
 * buffers that hold database records from given table.
 */
#ifndef MODULE_APPS_DATABASEMODEL_HPP_
#define MODULE_APPS_DATABASEMODEL_HPP_

#include <cstdint>
#include <vector>
#include <utility>
#include <algorithm>

#include "Application.hpp"

namespace app {

/*
 *
 */
template <class T> class DatabaseModel {
protected:
	/**
	 * Number of elements requested from database in single message
	 */
	int pageSize = 1;
	/**
	 * Pointer to application that owns the model
	 */
	Application* application;
	/**
	 * Total number of records in database
	 */
	int recordsCount;
	/**
	 * Index of first element in current page
	 */
	int firstIndex;
	//vector that holds records received from database - first last records, than previous records and finally next records
	std::vector<std::shared_ptr<T>> records;
public:

	virtual void requestRecordsCount() {
	}

	virtual bool updateRecords( std::unique_ptr<std::vector<T>> records, const uint32_t offset, const uint32_t limit, uint32_t count ) {
		//calculate for which page is received data using offset value

		int page = getPage(offset);
		int currentPage = firstIndex / pageSize;

		if( (page >= currentPage - 1) && ( page <= currentPage + 1)){

			//store new records
			for( unsigned int i=0; i<count; i++ ) {
				auto ii = i+(pageSize*(page-currentPage) + pageSize)+offset% pageSize;
				this->records[ii] = nullptr;
				this->records[i+(pageSize*(page-currentPage) + pageSize)+offset% pageSize] = std::make_shared<T>( records.get()->operator [](i) );
				//this->records[i+(pageSize*(page-currentPage) + pageSize)+offset% limit] = std::shared_ptr<T>( new T(records.get()->operator [](i)) );
			}

			//return true (for refreshing window) only if current page was modified.
			if( page == currentPage )
				return true;
			return false;
		}
		else {
			//alarms are out of current scope
			LOG_ERROR("Received records out of scope");
			return false;
		}
		return false;
	}

	virtual void movePrevWindow() {

		uint32_t currentPage = firstIndex / pageSize;
		//check if it is possible to move to previous window
		if( currentPage <= 0 )
			return;

		//erase records from next window
		for( int i=0; i<pageSize; i++ )
			if( records[i+2*pageSize]) {
				records[i+2*pageSize] = nullptr;
			}

		//moves current records to next records and prev records to current records
		for( int i=3*pageSize-1; i>=pageSize; --i )
			records[i] = records[i-pageSize];

		//clear first window to nullptr
		for( int i = 0; i<pageSize; ++i )
			records[i] = nullptr;

		//lock the application for keyboard input
		application->blockEvents(true);

		//request records for next window
		int prevPage = currentPage - 2;
		if( prevPage >= 0) {
			requestRecords(pageSize*prevPage, pageSize );
		}
		firstIndex -= pageSize;
		if( firstIndex < 0 )
			firstIndex = 0;
	}

	virtual void moveNextWindow() {

		uint32_t currentPage = firstIndex / pageSize;
		uint32_t pageCount = (recordsCount % pageSize == 0) ? recordsCount/pageSize : (recordsCount/pageSize)  + 1;
		//check if it is possible to move to next window
		if( currentPage >= pageCount )
			return;

		//erase firswt window with indicies from 0 up to pageSize -1
		for( int i=0; i<pageSize; i++ )
			if( records[i] )
				records[i] = nullptr;

		//move current and next window so current window becomes prev window and next becomes current.
		for( int i=0; i<2*pageSize; ++i )
			records[i] = records[i+pageSize];

		//clear last window to nullptr
		for( int i= 2*pageSize; i<3*pageSize; ++i )
			records[i] = nullptr;

		//lock the application for keyboard input
		application->blockEvents(true);

		//request records for next window
		uint32_t nextPage = currentPage + 2;
		if( nextPage < pageCount )
			requestRecords(pageSize*nextPage, pageSize );
		firstIndex += pageSize;
		if( firstIndex > recordsCount )
			firstIndex = recordsCount/pageCount;
	}

	virtual void requestRecords( const uint32_t offset, const uint32_t limit ) = 0;

	bool setRecordsCount( int count ) {

		clear();
		recordsCount = count;

		//if there are any records request blocks of data from database using recordsLocalCount and requestSize.
		if( recordsCount ) {

			//TODO handle validation for firstIndex when number of records has decreased.
			requestRecords(firstIndex, pageSize );
			if( firstIndex + pageSize < recordsCount )
				requestRecords(firstIndex+pageSize, pageSize );
			return true;
		}
		return false;
	}

	void setPageSize( int size ) {
		clear();
		pageSize = size;
		firstIndex = 0;

		records.resize(3*pageSize);
		std::fill( records.begin(), records.end(), nullptr );
	}

	DatabaseModel( Application* app, int pageSize ) :
		pageSize{pageSize},
		application{app},
		recordsCount{ -1 },
		firstIndex{ 0 } {

		records.resize( pageSize*3 );
		std::fill( records.begin(), records.end(), nullptr );
	}

	virtual ~DatabaseModel() {
		clear();
	}

	virtual void clear() {

		for( int i=0; i< pageSize*3; i++ )
			records[i] = nullptr;
		records.clear();
		firstIndex = 0;
		recordsCount = -1;
	}

	int getRecordsCount() {
		return recordsCount;
	}

	int getPage( uint32_t index ) {
		return  (index % pageSize == 0) ? index/pageSize : (index/pageSize);
	}

	/**
	 * @brief Returns database object under specified index. Performs forward and backward buffering.
	 * @index Index of the database element. Starts from 0 ( database objects have lowest ID equal to 1. )
	 * @download Flag that controls whether model should download objects from database when requested object is
	 * outside visible window.
	 */
	std::shared_ptr<T> getRecord( int index, bool download = true ) {

		//if index is greater than number of records or smaller than 0
		if( (index<0) || (index>recordsCount-1)){
			return nullptr;
		}
		//if index is in current window
		if( (index >= firstIndex) && ( index < firstIndex + pageSize)) {
			return records[pageSize + index-firstIndex];
		}
		//if download is false check if requested element is in any of the windows
		if( (download == false ) && (index >= firstIndex - pageSize ) && ( index < firstIndex + 2*pageSize)) {
			return records[pageSize + index-firstIndex];
		}
		//if index is in next window
		if( download && (index >= firstIndex + pageSize) && ( index < firstIndex+2*pageSize) ) {
			std::shared_ptr<T> record = records[pageSize + index - firstIndex];
			moveNextWindow();
			return record;
		}
		//if index is in previous window
		if( download && (index >= firstIndex - pageSize) && ( index < firstIndex) ) {
			std::shared_ptr<T> record = records[index+ pageSize-firstIndex];
			movePrevWindow();
			return record;
		}
		//if index is not in prev, current or next window
		else if( (index < firstIndex - pageSize) || (index>firstIndex + 2*pageSize) ){
			int newCurrentPage = index/pageSize;
			clear();
			firstIndex = pageSize * newCurrentPage;
			//request current page
			requestRecords(firstIndex, pageSize );
			//if possible request previous page;
			if( firstIndex - 1 > 0 )
				requestRecords(firstIndex - pageSize, pageSize);
			//if possible request next window
			if( firstIndex*(pageSize + 1) <= recordsCount - 1 )
				requestRecords(firstIndex+pageSize, pageSize);

			return nullptr;
		}
		return nullptr;
	}
};

} /* namespace app */

#endif /* MODULE_APPS_DATABASEMODEL_HPP_ */