devicecache.cpp

It s a tool designed to extract as much information as possible from Bluetooth devices without the r

/* -*- c++ -*- ---------------------------------------------------------------
   Copyright (C) 2005, SWECO, All Rights Reserved.

   Implementation of DeviceRecoveryLogic class

   Author: Zsolt Molnar ([e-mail])
   ---------------------------------------------------------------------------*/

#include <fstream>
#include <iostream>
#include "DeviceCache.hh"

namespace { 
	const char rcs_id[] = "$Id$"; 
}

void  
DeviceCache::setMaxSize(const size_t aMaxSize)
{
  // Delete oldest elements if the number of elements more than the new maximal
  // size.
  if (aMaxSize < size()) {
	  // Remove only those objectd that are not in "CONNECTED" state or
	  // not locked by a thread
	  for (iterator itr = begin() + aMaxSize; itr != end(); ++itr) {
		  if ((*itr)->state != CONNECTED && !(*itr)->isLocked()) {
			  delete *itr;
			  itr = erase(itr) - 1;
		  }
	  }
    }
  // Set new maximal size.
  iMaxSize = aMaxSize;
}


bool
DeviceCache::save()
{
	ofstream out(_fileName.c_str());
	
	if (!out) {
		return false;
	}

	for (iterator itr = begin(); itr != end(); ++itr) {
		out << (**itr);
	}

	return true;
}


bool
DeviceCache::load()
{
	ifstream in(_fileName.c_str());
	
	if (!in) {
		return false;
	}

	size_t max_size = maxSize();
	setMaxSize(0);
	setMaxSize(max_size);

	while (!in.eof()) {
		DeviceRecord* item = new DeviceRecord(Device(""));
		in >> *item;
		//insert(begin(), item);
		push_back(item);
	}
	
	if (!empty()) {
		pop_back();
	}

	return true;
}


#ifdef __TEST__
#include <assert.h>
#include <iostream>

bool
DeviceCache::test()
{
	Device dev1("dev1");
	Device dev2("dev2");
	Device dev3("dev3");
	DeviceRecord devrec_1(dev1);
	DeviceRecord devrec_2(dev2);
	DeviceRecord devrec_3(dev3, CONNECTED);

	setMaxSize(2);

	// 1 element added
	accessElem(devrec_1);
	assert(size() == 1);
	// 1 more element
	accessElem(devrec_2);
	assert(size() == 2);
	assert(*(*this)[0] == devrec_2);
	assert(*(*this)[1] == devrec_1);
	// 1 more element
	accessElem(devrec_1);
	assert(size() == 2);
	assert(*(*this)[0] == devrec_1);
	assert(*(*this)[1] == devrec_2);
	// 1 more element
	accessElem(devrec_3);
	assert(size() == 2);
	assert(*(*this)[0] == devrec_3);
	assert(*(*this)[1] == devrec_1);
	// 1 more element
	accessElem(devrec_2);
	assert(size() == 2);
	assert(*(*this)[0] == devrec_2);
	assert(*(*this)[1] == devrec_3);
	// 1 more element
	accessElem(devrec_1);
	assert(size() == 3);
	assert(*(*this)[0] == devrec_1);
	assert(*(*this)[1] == devrec_2);
	assert(*(*this)[2] == devrec_3);
	// The last element goes up
	accessElem(devrec_3).state = UNCONNECTED;
	assert(size() == 2);
	assert(*(*this)[0] == devrec_3);
	assert(*(*this)[1] == devrec_1);
	// 1 element goes up
	accessElem(devrec_1);
	assert(size() == 2);
	assert(*(*this)[0] == devrec_1);
	assert(*(*this)[1] == devrec_3);
	// 1 element goes up
	accessElem(devrec_2);
	assert(size() == 2);
	assert(*(*this)[0] == devrec_2);
	assert(*(*this)[1] == devrec_1);
	// last element is locked and 1 element comes
	(*this)[1]->lock();
	accessElem(devrec_3);
	assert(size() == 3);
	assert(*(*this)[0] == devrec_3);
	assert(*(*this)[1] == devrec_2);
	assert(*(*this)[2] == devrec_1);
	// Lock goes away and 1 element comes
	(*this)[2]->unlock();
	accessElem(devrec_1);
	assert(size() == 2);
	assert(*(*this)[0] == devrec_1);
	assert(*(*this)[1] == devrec_3);


	// Test persistency
	save();
	DeviceCache cache2(2, "devcache.db");
	cache2.load();
	assert(cache2.size() == 2);
	assert(*(cache2[0]) == devrec_1);
	assert(*(cache2[1]) == devrec_3);

	cout << "DeviceCache test passed" << endl;
	return true;
}
#endif // #ifdef __TEST__