/**
* Creates a list of all events.
**/
std::string generateEventsTable(const std::list<Event>& events)
{
std::ostringstream ss;
unsigned int counter = 1;
char timeBuffer[100] = {0};
char timeline[26];
for (std::list<Event>::const_iterator Iter = events.begin(); Iter != events.end(); ++Iter)
{
createRow(ss, counter);
createCell(ss, counter, "center");
_timeb eventTime = Iter->getTime();
ctime_s( timeline, 26, & ( eventTime.time ) );
sprintf(timeBuffer, "%.8s.%hu", timeline + 11, eventTime.millitm);
createCell(ss, timeBuffer, "center");
ss << "<td style=\"text-align:center\">";
ss << "0x" << std::uppercase << std::hex << Iter->getAddress().getAddress() << std::dec << std::nouppercase;
ss << "</td>";
createCell(ss, Iter->getParentFunction().getName(), "left");
++counter;
}
return ss.str();
}
bool updateLeavesSpawn() {
bool fullGridSpawn = (newLeaves.size() == (unsigned)theHeriswapGridSystem.GridSize*theHeriswapGridSystem.GridSize);
ADSR(haveToAddLeavesInGrid)->active = true;
for ( std::vector<Feuille>::reverse_iterator it = newLeaves.rbegin(); it != newLeaves.rend(); ++it ) {
if (it->entity == 0) {
it->entity = createCell(*it, fullGridSpawn);
} else {
HeriswapGridComponent* gc = HERISWAPGRID(it->entity);
if (fullGridSpawn) {
gc->i = gc->j = -1;
}
TransformationComponent* tc = TRANSFORM(it->entity);
//leaves grow up from 0 to fixed size
glm::vec2 s = HeriswapGame::CellSize(theHeriswapGridSystem.GridSize, gc->type);
if (ADSR(haveToAddLeavesInGrid)->value == 1){
tc->size = glm::vec2(s.x, s.y);
gc->i = it->X;
gc->j = it->Y;
} else {
tc->size = s * ADSR(haveToAddLeavesInGrid)->value;
}
}
}
return (ADSR(haveToAddLeavesInGrid)->value == 1);
}
ossimRefPtr<ossimElevCellHandler> ossimElevationCellDatabase::getOrCreateCellHandler(const ossimGpt& gpt)
{
ossimRefPtr<ossimElevCellHandler> result = 0;
ossim_uint64 id = createId(gpt);
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(m_cacheMapMutex);
CellMap::iterator iter = m_cacheMap.find(id);
if(iter != m_cacheMap.end())
{
iter->second->updateTimestamp();
result = iter->second->m_handler.get();
return result.get();
}
}
result = createCell(gpt);
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(m_cacheMapMutex);
if(result.valid())
{
m_cacheMap.insert(std::make_pair(id, new CellInfo(id, result.get())));
// Check the map size and purge cells if needed.
if(m_cacheMap.size() > m_maxOpenCells)
{
flushCacheToMinOpenCells();
}
}
}
return result;
}
///----------------------------------------------------------------------------//
///--------------------- ENTER SECTION ----------------------------------------//
///----------------------------------------------------------------------------//
void onPreEnter(Scene::Enum from) override {
// Prepare game
if (from == Scene::CountDown) {
game->datas->faderHelper.start(Fading::In, 0.5);
}
ADSR(haveToAddLeavesInGrid)->attackTiming = game->datas->timing.haveToAddLeavesInGrid;
ADSR(replaceGrid)->attackTiming = game->datas->timing.replaceGrid;
fillTheBlank(newLeaves);
//we need to create the whole grid (start game and level change)
if ((int)newLeaves.size() == theHeriswapGridSystem.GridSize*theHeriswapGridSystem.GridSize) {
LOGI("create '" << newLeaves.size() << "' cells");
for(unsigned int i=0; i<newLeaves.size(); i++) {
if (newLeaves[i].entity == 0)
newLeaves[i].entity = createCell(newLeaves[i], true);
}
ADSR(haveToAddLeavesInGrid)->active = true;
removeEntitiesInCombination();
} else {
ADSR(haveToAddLeavesInGrid)->active = false;
}
ADSR(haveToAddLeavesInGrid)->activationTime = 0;
ADSR(replaceGrid)->activationTime = 0;
ADSR(replaceGrid)->active = false;
}
GLECSVDataStatus GLECSVData::readCellString(GLEBYTE quote) {
unsigned int cellSize = 1;
unsigned int cellPos = lastCharPos();
initWritePos();
while (true) {
GLEBYTE ch = readChar();
writeChar(ch);
cellSize++;
if (ch == 0) {
m_error.errorCode = GLECSVErrorUnterminatedString;
m_error.errorLine = m_lines;
m_error.errorColumn = getUTF8Column(cellPos);
createErrorString("unterminated string");
return GLECSVDataStatusEOF;
} else if (isEol(ch)) {
m_error.errorCode = GLECSVErrorUnterminatedString;
m_error.errorLine = m_lines;
m_error.errorColumn = getUTF8Column(cellPos);
createErrorString("unterminated string");
return readNewline(ch);
} else if (ch == quote) {
GLEBYTE ch = readChar();
if (ch != quote) {
writeChar(ch);
createCell(cellSize, cellPos);
return skipSpacesAndFirstDelim(ch);
}
}
}
return GLECSVDataStatusOK;
}
void WTableRow::insertColumn(int column)
{
cells_.insert(cells_.begin() + column, createCell(column));
WTableCell *cell = cells_[column].get();
if (table_)
table_->widgetAdded(cell);
cell->row_ = this;
cell->column_ = column;
for (unsigned i = column; i < cells_.size(); ++i)
cells_[i]->column_ = i;
}
void WTableRow::expand(int numCells)
{
int cursize = cells_.size();
for (int col = cursize; col < numCells; ++col) {
cells_.push_back(createCell(col));
WTableCell *cell = cells_.back().get();
if (table_)
table_->widgetAdded(cell);
cell->row_ = this;
cell->column_ = col;
}
}
GLECSVDataStatus GLECSVData::readCell() {
GLEBYTE ch = readSignificantChar();
if (ch == '"' || ch == '\'') {
return readCellString(ch);
}
unsigned int cellCount = 0;
unsigned int cellSize = 0;
unsigned int cellPos = lastCharPos();
while (true) {
if (ch == 0) {
if (isSizeCheckOKEndOfLine(cellSize)) {
createCell(cellSize, cellPos);
}
return GLECSVDataStatusEOF;
} else if (isEol(ch)) {
if (isSizeCheckOKEndOfLine(cellSize)) {
createCell(cellSize, cellPos);
}
return readNewline(ch);
} else if (isDelim(ch)) {
m_lastDelimWasSpace = isSpace(ch);
if (isSizeCheckOKAtDelim(ch, cellSize)) {
createCell(cellSize, cellPos);
}
return skipSpacesAndFirstDelim(ch);
} else if (isComment(ch)) {
if (isSizeCheckOKEndOfLine(cellSize)) {
createCell(cellSize, cellPos);
}
return skipTillEol();
}
cellCount++;
if (!isSpace(ch)) {
cellSize = cellCount;
}
ch = readChar();
}
return GLECSVDataStatusOK;
}
/** \brief Create the grid with char from a file
*
* \param Cell[][] : array of Cell
* \param char[][] : array of char
*
*/
void createGrid(Cell grid[N][N], char charFile[]) {
int i, j;
int x = 0;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
grid[i][j] = createCell(charFile[x]);
x++;
}
}
}
HashCell *addCell(HashCell *cell, StringXXX *key){
HashCell *tmp = cell;
while (tmp != nullptr){
if (areEqual(tmp->key, key)){
tmp->howMuch++;
deleteString(key);
return cell;
}
tmp = tmp->next;
}
HashCell *newCell = createCell(key);
newCell->next = cell;
newCell->howMuch++;
return newCell;
}
/**
* Generates a HTML table that is used to display function events sorted by a given sorter.
**/
std::string generateFunctionTable(std::list<TimedBlock*>& functionResults, bool (*sorter)(const TimedBlock*, const TimedBlock*))
{
functionResults.sort(sorter);
time_t totalTime = ::totalTime(functionResults);
unsigned int totalHits = ::totalHits(functionResults);
std::ostringstream ss;
unsigned int counter = 1;
for (std::list<TimedBlock*>::const_iterator Iter = functionResults.begin(); Iter != functionResults.end(); ++Iter)
{
TimedBlock* bb = *Iter;
if (bb->getHits() == 0)
{
// We can not break here because it's not guaranteed that useful events come later,
// depending on the exact sort algorithm.
continue;
}
createRow(ss, counter);
createCell(ss, counter, "center");
createCell(ss, bb->getParentFunction().getName(), "left");
ss << "<td style=\"text-align:center\">";
ss << "0x" << std::uppercase << std::hex << bb->getParentFunction().getAddress().getAddress() << std::nouppercase;
ss << "</td>";
ss << std::dec << std::fixed << std::setprecision(2);
createCell(ss, bb->getTime(), "right", " ms");
createCell(ss, 100.0 * bb->getTime() / totalTime, "right", " %");
createCell(ss, bb->getHits(), "right");
createCell(ss, 100.0 * bb->getHits() / totalHits, "right", " %");
createCell(ss, 1.0 * bb->getTime() / bb->getHits(), "right", " ms");
ss << "</tr>";
++counter;
}
return ss.str();
}
void Column::insertRow(const RowId& newRowId, int index)
{
ICell* pNewCell = createCell(newRowId, index);
m_cells.insert(m_cells.begin()+index, pNewCell);
}
Cell::Cell(int _iDims, const int* _piDims, InternalType** data)
{
createCell(_iDims, _piDims, data);
}
Cell::Cell(int _iRows, int _iCols, InternalType** data)
{
int piDims[2] = {_iRows, _iCols};
createCell(2, piDims, data);
}
/**
** Constructor & Destructor (public)
*/
Cell::Cell()
{
int piDims[2] = {0, 0};
createCell(2, piDims, nullptr);
}
ossimRefPtr<ossimElevCellHandler> ossimImageElevationDatabase::getOrCreateCellHandler(
const ossimGpt& gpt)
{
ossimRefPtr<ossimElevCellHandler> result = 0;
// Note: Must do mutex lock / unlock around any cach map access.
m_cacheMapMutex.lock();
if ( m_cacheMap.size() )
{
//---
// Look in existing map for handler.
//
// Note: Cannot key off of id from gpt as cells can be any arbituary dimensions.
//---
CellMap::iterator lastAccessedCellIter = m_cacheMap.find(m_lastAccessedId);
CellMap::iterator iter = lastAccessedCellIter;
// Check from last accessed to end.
while ( iter != m_cacheMap.end() )
{
if ( iter->second->m_handler->pointHasCoverage(gpt) )
{
result = iter->second->m_handler.get();
break;
}
++iter;
}
if ( result.valid() == false )
{
iter = m_cacheMap.begin();
// Beginning to last accessed.
while ( iter != lastAccessedCellIter)
{
if ( iter->second->m_handler->pointHasCoverage(gpt) )
{
result = iter->second->m_handler.get();
break;
}
++iter;
}
}
if ( result.valid() )
{
m_lastAccessedId = iter->second->m_id;
iter->second->updateTimestamp();
}
}
m_cacheMapMutex.unlock();
if ( result.valid() == false )
{
// Not in m_cacheMap. Create a new cell for point if we have coverage.
result = createCell(gpt);
if(result.valid())
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(m_cacheMapMutex);
//---
// Add the cell to map.
// NOTE: ossimImageElevationDatabase::createCell sets m_lastAccessedId to that of
// the entries map key.
//---
m_cacheMap.insert(std::make_pair(m_lastAccessedId,
new CellInfo(m_lastAccessedId, result.get())));
++m_lastMapKey;
// Check the map size and purge cells if needed.
if(m_cacheMap.size() > m_maxOpenCells)
{
flushCacheToMinOpenCells();
}
}
}
return result;
}
