Records Database::children(const RecordID& idParent) const
{
Records result;
Dbc* pCursor = nullptr;
dbParentId_.cursor(NULL, &pCursor, 0);
assert(pCursor);
BOOST_SCOPE_EXIT(&pCursor)
{
pCursor->close();
} BOOST_SCOPE_EXIT_END
Dbt keyParent(idParent.data(), idParent.size());
Dbt keyChild;
Dbt record;
int res = pCursor->pget(&keyParent, &keyChild, &record, DB_SET);
while (res == 0)
{
result.push_back(make_Record(RecordID(keyChild), RecordData(record)));
res = pCursor->pget(&keyParent, &keyChild, &record, DB_NEXT_DUP);
}
return result;
}
Records PostgreSQL::Result::records() const {
Records recs;
recs.resize(recordNum());
for (size_t i = 0; i < recordNum(); i++) {
recs[i].reserve(fieldNum());
for (size_t i2 = 0; i2 < fieldNum(); i2++)
recs[i].push_back(PQgetvalue(res, i, i2));
}
return recs;
}
Records OCILib::Result::records() const {
if (!res)
return Records();
Records recs;
while(true)
{
Record r=OCILib::Cursor::fetchOneRow();
if(r.empty())
break;
recs.push_back(r);
}
return recs;
}
LITESQL_String Persistent::insert(Record& tables,
Records& fieldRecs,
Records& values,
const LITESQL_String& sequence) {
if (values[0][0] == LITESQL_L("0"))
for(size_t i = 0; i < values.size(); i++)
values[i][0] = LITESQL_L("NULL");
LITESQL_String key = db->groupInsert(tables, fieldRecs, values, sequence);
oldKey = atoi(key);
inDatabase = true;
return key;
}
void ScanThread::scanDir(
const RecordID& dirId,
EntriesIt itEntriesBegin,
EntriesIt itEntriesEnd)
{
if (shouldBreak())
{
return;
}
Records oldRecords = db_.children(dirId);
std::sort(oldRecords.begin(), oldRecords.end(), CmpByPath());
auto entriesRange = boost::make_iterator_range(itEntriesBegin, itEntriesEnd);
for (const auto& entry : entriesRange)
{
scanEntry(getPath(entry), dirId, oldRecords, isRecursive(entry));
if (shouldBreak())
{
return;
}
}
for (const Record& missing : oldRecords)
{
try
{
delEntry(missing.first);
}
catch(std::exception const& ex)
{
std::cerr << "Failed to delete DB record for '"
<< missing.second.header.fileName << "' entry: "
<< ex.what() << std::endl;
}
}
}
Status HashTable::isinBucket(Records _r, unsigned int _prefix) {
string bit_rep = bitset<32>(HASH(_r.getData())).to_string();
string tmp = bitset<32>(HashMSB).to_string();
string HashMSB_bit = tmp.substr((32 - _prefix), tmp.npos);
//Print for Testing purposes
//cout << "Hash prefix: " << HashMSB_bit << endl;
//cout << "Record Value: " << bit_rep << endl;
//Match Prefixes
if (PREFIXMATCH != matchPrefix(HashMSB_bit,bit_rep,_prefix))
{
return NOTINBUCKET;
}
return INBUCKET;
}
RootController(ci::JsonTree& params,
ci::TimelineRef timeline,
Event<std::vector<Touch> >& touch_event) noexcept :
params_(params),
timeline_(timeline),
ui_camera_(createCamera(params["ui_view.camera"])),
fov_(ui_camera_.getFov()),
near_z_(ui_camera_.getNearClip()),
far_z_(ui_camera_.getFarClip()),
autolayout_(ui_camera_),
touch_event_(touch_event),
view_creator_(params, timeline, ui_camera_, autolayout_, event_, touch_event),
sound_(params["sounds"]),
background_(Json::getColor<float>(params["app.background"])),
records_(params["version"].getValue<float>())
{
DOUT << "RootController()" << std::endl;
event_.connect("begin-progress",
[this](const Connection&, EventParam& param) noexcept {
addController<ProgressController>(params_, timeline_, event_,
view_creator_.create("ui_progress.json"));
});
event_.connect("begin-gameover",
[this](const Connection&, EventParam& param) noexcept {
addController<GameoverController>(params_, timeline_, event_,
param,
view_creator_.create("ui_gameover.json"));
});
event_.connect("begin-stageclear",
[this](const Connection&, EventParam& param) noexcept {
addController<StageclearController>(params_, timeline_, event_, param,
view_creator_.create("ui_stageclear.json"));
});
event_.connect("begin-pause",
[this](const Connection&, EventParam& param) noexcept {
addController<PauseController>(params_, timeline_, event_,
view_creator_.create("ui_pause.json"));
});
event_.connect("begin-records",
[this](const Connection&, EventParam& param) noexcept {
EventParam records = {
{ "total_play", records_.getTotalPlayNum() },
{ "total_time", records_.getTotalPlayTime() },
{ "high_score", records_.getHighScore() },
{ "total_item", records_.getTotalItemNum() },
{ "stage_ranks", records_.stageRanks() },
};
addController<RecordsController>(params_, timeline_, event_, records,
view_creator_.create("ui_records.json"));
});
event_.connect("begin-credits",
[this](const Connection&, EventParam& param) noexcept {
addController<CreditsController>(params_, timeline_, event_,
view_creator_.create("ui_credits.json"));
});
event_.connect("begin-title",
[this](const Connection&, EventParam& param) noexcept {
startTitle(param);
});
event_.connect("begin-settings",
[this](const Connection&, EventParam& param) noexcept {
addController<SettingsController>(params_, timeline_, event_, records_,
view_creator_.create("ui_settings.json"));
});
event_.connect("begin-regulat-stageclear",
[this](const Connection&, EventParam& param) noexcept {
addController<AllStageClearController>(params_["regular_stageclear"], timeline_, event_,
param,
view_creator_.create("ui_regularstageclear.json"));
});
event_.connect("begin-all-stageclear",
[this](const Connection&, EventParam& param) noexcept {
addController<AllStageClearController>(params_["all_stageclear"], timeline_, event_,
param,
view_creator_.create("ui_allstageclear.json"));
});
// GameOver時に色々チェック
event_.connect("check-after-gameover",
[this](const Connection&, EventParam& param) noexcept {
DOUT << "check-after-gameover" << std::endl;
Rating::popup([this]() {
AppSupport::pauseDraw(true);
},
[this]() {
AppSupport::pauseDraw(false);
});
Achievment::atGameOver(records_);
});
// サウンド再生
event_.connect("sound-play",
[this](const Connection&, EventParam& param) noexcept {
auto& name = boost::any_cast<const std::string&>(param.at("sound"));
player_.play(name);
// DOUT << "sound:" << name << std::endl;
});
event_.connect("se-silent",
[this](const Connection&, EventParam& param) noexcept {
sound_.setBufferSilent(boost::any_cast<bool>(param["silent"]));
});
event_.connect("bgm-silent",
[this](const Connection&, EventParam& param) noexcept {
sound_.setFileSilent(boost::any_cast<bool>(param["silent"]));
});
#ifdef DEBUG
event_.connect("force-regular-completed",
[this](const Connection&, EventParam& param) noexcept {
records_.forceRegularStageComplated();
});
event_.connect("cancel-regular-completed",
[this](const Connection&, EventParam& param) noexcept {
records_.cancelRegularStageComplated();
});
event_.connect("clear-records",
[this](const Connection&, EventParam& param) noexcept {
records_ = Records(params_["version"].getValue<float>());
});
event_.connect("do-snapshot",
[this](const Connection&, EventParam& param) noexcept {
auto surface = ci::app::copyWindowSurface();
auto full_path = getDocumentPath() / std::string("snapshot" + createUniquePath() + ".png");
ci::writeImage(full_path, surface);
});
event_.connect("reset-records",
[this](const Connection&, EventParam& param) noexcept {
records_ = Records(params_["version"].getValue<float>());
});
event_.connect("reset-achievement",
[this](const Connection&, EventParam& param) noexcept {
DOUT << "reset-achievement" << std::endl;
GameCenter::resetAchievement();
});
#endif
records_.load(params["game.records"].getValue<std::string>());
sound_.setBufferSilent(!records_.isSeOn());
sound_.setFileSilent(!records_.isBgmOn());
addController<FieldController>(params, touch_event_, event_, records_);
addController<IntroController>(params_, timeline_, event_,
records_.getTotalPlayNum(),
view_creator_.create("ui_intro.json"));
// 自動PAUSE
// getSignalDidEnterBackground(Backgroundになった直後)
// getSignalWillResignActive(アクティブでなくなる直前)
resign_active_ = ci::app::App::get()->getSignalWillResignActive().connect([this]() noexcept {
DOUT << "SignalWillResignActive" << std::endl;
EventParam params = {
{ "force", true }
};
event_.signal("pause-agree", params);
GameCenter::writeCachedAchievement();
});
}
Row Project::get(Dir dir)
{
static Record emptyrec;
if (first)
{
first = false;
src_hdr = source->header();
proj_hdr = src_hdr.project(flds);
if (strategy == LOOKUP)
{
if (idx)
idx->free();
idx = new VVtree(td = new TempDest);
indexed = false;
}
}
if (strategy == COPY)
{
return source->get(dir);
}
else if (strategy == SEQUENTIAL)
{
if (dir == NEXT)
{
// output the first of each group
// i.e. skip over rows the same as previous output
Row row;
do
if (Eof == (row = source->get(NEXT)))
return Eof;
while (! rewound && equal(proj_hdr, row, currow));
rewound = false;
prevrow = currow;
currow = row;
// output the first row of a new group
return Row(lisp(emptyrec, row_to_key(src_hdr, row, flds)));
}
else // dir == PREV
{
// output the last of each group
// i.e. output when *next* record is different
// (to get the same records as NEXT)
if (rewound)
prevrow = source->get(PREV);
rewound = false;
Row row;
do
{
if (Eof == (row = prevrow))
return Eof;
prevrow = source->get(PREV);
}
while (equal(proj_hdr, row, prevrow));
// output the last row of a group
currow = row;
return Row(lisp(emptyrec, row_to_key(src_hdr, row, flds)));
}
}
else
{
verify(strategy == LOOKUP);
if (rewound)
{
rewound = false;
if (dir == PREV && ! indexed)
{
// pre-build the index
Row row;
while (Eof != (row = source->get(NEXT)))
{
Record key = row_to_key(src_hdr, row, flds);
Vdata data(row.data);
for (Lisp<Record> rs = row.data; ! nil(rs); ++rs)
td->addref(rs->ptr());
// insert will only succeed on first of dups
idx->insert(VVslot(key, &data));
}
source->rewind();
indexed = true;
}
}
Row row;
while (Eof != (row = source->get(dir)))
{
Record key = row_to_key(src_hdr, row, flds);
VVtree::iterator iter = idx->find(key);
if (iter == idx->end())
{
for (Lisp<Record> rs = row.data; ! nil(rs); ++rs)
td->addref(rs->ptr());
Vdata data(row.data);
verify(idx->insert(VVslot(key, &data)));
return Row(lisp(emptyrec, key));
}
else
{
Vdata* d = iter->data;
Records rs;
for (int i = d->n - 1; i >= 0; --i)
rs.push(Record::from_int(d->r[i], theDB()->mmf));
Row irow(rs);
if (row == irow)
return Row(lisp(emptyrec, key));
}
}
if (dir == NEXT)
indexed = true;
return Eof;
}
}
void ScanThread::scanEntry(
const fs::path& path,
const RecordID& parentID,
Records& oldRecords,
bool recursive)
try
{
if (shouldBreak())
{
return;
}
const bool isDir = fs::is_directory(path);
Record newRecord = make_Record(
NULL_RECORD_ID,
RecordData(parentID, /*last write time*/0, isDir, path.string()));
const std::pair<Records::iterator, Records::iterator> oldRange =
std::equal_range(oldRecords.begin(), oldRecords.end(), newRecord, CmpByPath());
assert(std::distance(oldRange.first, oldRange.second) <= 1);
const Records::iterator itOldRecord = oldRange.first != oldRange.second ?
oldRange.first : oldRecords.end();
if (isDir && recursive)
{
// if new entry
if (itOldRecord == oldRecords.end())
{
addEntry(std::move(newRecord.second));
}
}
else // file
{
if (!isSupportedExtension(path))
{
return; // unsupported extension
}
newRecord.second.header.lastWriteTime = fs::last_write_time(path);
if (itOldRecord == oldRecords.end())
{
addEntry(std::move(newRecord.second));
}
else if(newRecord.second.header.lastWriteTime !=
itOldRecord->second.header.lastWriteTime)
{
newRecord.first = itOldRecord->first;
replaceEntry(std::move(newRecord));
}
}
// record was processed, so removing from the list
if (oldRecords.end() != itOldRecord)
{
oldRecords.erase(itOldRecord);
}
}
catch(const fs::filesystem_error& ex)
{
std::cerr << "Failed to process filesystem element "
<< path << ": " << ex.what() << std::endl;
// if the entry is inaccessible due to network resource down
// it shouldn't be deleted from the database
if (ex.code().value() != ENOENT)
{
const Record fakeRecord = make_Record(NULL_RECORD_ID,
RecordData(NULL_RECORD_ID, 0, false, path.string()));
const Records::iterator itOldRecord = std::lower_bound(
oldRecords.begin(), oldRecords.end(), fakeRecord, CmpByPath());
// prevent record from deletion
if (oldRecords.end() != itOldRecord)
{
oldRecords.erase(itOldRecord);
}
}
}
catch(const std::exception& ex)
{
std::cerr << "Failed to process filesystem element "
<< path << ": " << ex.what() << std::endl;
}
