Highscore::Highscore(GameType type) : type_(type), blink_(nullptr) {
if(type == NORMAL)
{
filename_ = getPaths().getConfig() + "normal.txt";
}
else if(type == FIFTYLINES)
{
filename_ = (getPaths().getConfig() + "fiftylines.txt");
}
else
{
throw std::runtime_error("Unknown GameType");
}
std::ifstream fin(filename_);
if(fin)
{
for(int i = 0; i < 5; ++i)
{
Data temp;
std::getline(fin, temp.name);
fin >> (temp.score) >> (temp.time);
highscores_.push_back(temp);
fin.ignore(3, '\n'); // Read till next \n
}
}
else
{
for(int i = 0; i < 5; ++i)
void getPaths(TreeNode* root, vector<string>& result, string str) {
if(root->left == NULL && root->right == NULL) {
result.push_back(str);
return;
}
if(root->left)
getPaths(root->left, result, str + "->" + to_string(root->left->val));
if(root->right)
getPaths(root->right, result, str + "->" + to_string(root->right->val));
}
Chooser::Chooser(int x, int y)
: previous_(""),
next_(""), sprite_("chooser"), x_(x), y_(y)
{
previous_.Connect(boost::bind(&Chooser::Previous, this));
previous_.SetSprites("chooser_left", "chooser_left_over", "chooser_left_over");
previous_.CenterAt(x - jngl::getWidth(getPaths().getGraphics() + sprite_) / 2 - previous_.GetWidth() / 2, y);
next_.Connect(boost::bind(&Chooser::Next, this));
next_.SetSprites("chooser_right", "chooser_right_over", "chooser_right_over");
next_.CenterAt(x + jngl::getWidth(getPaths().getGraphics() + sprite_) / 2 + next_.GetWidth() / 2, y);
}
void getPaths(TreeNode * root, vector<string> &ans, string path) {
if (! root) return;
path = (path == "") ? to_string(root->val) : (path + "->" + to_string(root->val));
if (! root->left && ! root->right) {
ans.push_back(path);
return;
}
if (root->left) getPaths(root->left, ans, path);
if (root->right) getPaths(root->right, ans, path);
}
void getPaths(TreeNode* root, vector<int> path, vector<string> &ret) {
path.push_back(root->val);
if (root->left == NULL && root->right == NULL) {
// new path
ret.push_back(formatPath(path));
} else {
if (root->left) {
getPaths(root->left, path, ret);
}
if (root->right) {
getPaths(root->right, path, ret);
}
}
}
void getPaths(TreeNode* root, vector<string>& res, string path){
if (root == NULL) {
return ;
}
else{
string tmp = path + "->" + std::to_string(root->val);
if(root->left == NULL && root->right == NULL){
res.push_back(tmp);
}
else {
getPaths(root->left, res, tmp);
getPaths(root->right, res, tmp);
}
}
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> res;
if (root == NULL) {
return res;
}
string path = std::to_string(root->val);
if (root->left || root->right) {
getPaths(root->left, res, path);
getPaths(root->right, res, path);
}
else{
res.push_back(path);
}
return res;
}
bool TypeLoader::findCSL( const std::string& typeName, std::string& fullPath, std::string& relativePath )
{
std::string names[2];
int n = 0;
// if the current namespace is not the root, first try a relative path
if( _namespace && _namespace->getParentNamespace() )
{
const std::string& fullNS = _namespace->getFullName();
names[n].reserve( fullNS.size() + typeName.size() + 5 );
names[n] = fullNS;
names[n].push_back( '.' );
names[n].append( typeName );
OS::convertDotsToDirSeps( names[n] );
names[n].append( ".csl" );
++n;
}
names[n].reserve( typeName.size() + 4 );
names[n] = typeName;
OS::convertDotsToDirSeps( names[n] );
names[n].append( ".csl" );
++n;
bool succeeded = OS::searchFile2( getPaths(), Slice<std::string>( names, n ),
fullPath, NULL, &relativePath );
if( !succeeded )
CORAL_THROW( co::Exception, "type '" << typeName << "' was not found in the path" );
return succeeded;
}
/* Get the absolute path of a file. Searches first in PATH.
* If not found in PATH, will check if fileName is already
* an absolute OR relative path.
* Accepts absolute paths with '~' representing HOME
* @param: string of the name or path of a file
* @return: string of absolute path of the file if found. NULL otherwise.
*/
char* getFilePath(char* fileName){
char** paths = getPaths();
char* filePath = NULL;
int i = 0;
filePath = malloc(PATH_MAX*sizeof(char));
while( paths[i] != NULL){
strcpy(filePath, paths[i]);
strcat(filePath, "/");
strcat(filePath, fileName);
if(doesFileExist(filePath)){
return filePath;
}
i++;
}
//File was not found in PATH
strcpy(filePath, fileName);
filePath = tildaToHome(filePath);
filePath = realpath(filePath, NULL);
if( filePath != NULL ){
return filePath;
}
return NULL;
}
int executeWhere(Cmd c){
int i =0;
char *path = getenv("PATH");
int noOfPaths=0;
char **paths = getPaths(path,&noOfPaths);
int count =0;
struct stat statbuf;
char *tmpChar;
printWhereBuiltIns(c->args[1]);
while(i<noOfPaths){
count =strlen(paths[i])+strlen(c->args[1])+2;
tmpChar = paths[i];
paths[i]=malloc(count*sizeof(char));
strcat(paths[i],tmpChar);
strcat(paths[i],"/");
strcat(paths[i],c->args[1]);
if(paths[i],stat(paths[i],&statbuf)==0){
// if(statbuf.st_mode & 0111){
printf("%s\n",paths[i]);
// }
}
i++;
}
return 0;
}
/*
* Изтрива всички директории в параметрите.
* Root директорият не може да се изтрие.
*/
void CommandPrompt::deleteDirectory(string parameters){
/*
* Извличаме адресите от параметрите.
*/
queue<string> dirPaths = getPaths(parameters);
/*
* Намираме директория по дадения път и викаме deleteFile().
* Ако е NULL извеждаме грешка.
* Ако текущата директория се съдържа в директорията която трием, я применяме на root.
* Root директорията не може да се изтрие.
*/
Directory* dir;
while (!dirPaths.empty()) {
dir = this->determinePathAndGetDir(dirPaths.front());
if (dir != NULL) {
if(currentDir->getFSysPath().find(dir->getFSysPath()) != string::npos){
currentDir = fs.getRoot();
cout << "Current directory now root!" << endl;
}
if (dir == fs.getRoot())
cerr << "Cannot delete root directory!" << endl;
else
dir->deleteFile();
}
else
cerr << "Directory not found!" << endl;
dirPaths.pop();
}
}
bool CBC::download(QString filename)
{
if(!compile(filename))
return false;
qWarning("Calling gcc...");
m_gcc.reset();
m_gcc.start(m_gccPath, QStringList() << "-E" << "-Wp,-MM" << filename);
m_gcc.waitForFinished();
qWarning("Gcc finished...");
QString depString = QString::fromLocal8Bit(m_gcc.readAllStandardOutput());
QStringList deps = getPaths(depString);
deps.removeFirst();
qWarning("deps.size()=%d", deps.size());
qWarning("deps=\"%s\"", qPrintable(deps.join(",")));
qWarning("Calling sendFile");
if(!QSerialPort(m_defaultPort).open(QIODevice::ReadWrite)) {
emit requestPort();
if(!QSerialPort(m_defaultPort).open(QIODevice::ReadWrite))
return false;
}
m_serial.setPort(m_defaultPort);
return m_serial.sendFile(filename, deps);
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> result;
if(root == NULL)
return result;
getPaths(root, result, to_string(root->val));
return result;
}
vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
unordered_set<string> dict(wordList.begin(), wordList.end());//list to set for quick membership check
if (!dict.count(endWord)) return {};//problem statement
dict.erase(beginWord); //why?
dict.erase(endWord); //why??
//steps store word -> steps from beginWord
unordered_map<string, int> steps{{beginWord, 1}}; //double }}
unordered_map<string, vector<string>> parents;
queue<string> q{{beginWord}};
//q.push(beginWord);
int step = 0;
bool found = false;
//found endWord at shortest level/step
while (!q.empty() && !found) {
++step;
//remove all elements from queue at this step/level
for (int size = q.size(); size > 0; size--) {
const string p = q.front(); q.pop();
string w = p; //copy p to w, w to change, p will be parent
for (int i = 0; i < w.size(); i++) { //for each letter position
const char ch = w[i];
for (char j = 'a'; j <= 'z'; j++) {
if (j == ch) continue;
w[i] = j;
//new word w is one letter diff
if (w == endWord) {
parents[w].push_back(p);
found = true;
} else {
// new word w != eneWord, but another transform
// with the same number of steps
//if (steps.count(w) && step < steps.at(w))
//why this?
if (steps.count(w) && step < steps[w])
parents[w].push_back(p);
}
if (dict.count(w) == 0) continue; // can not go to w
dict.erase(w); //to visit w, won't visit it again
q.push(w);
steps[w] = steps[p] + 1;
parents[w].push_back(p);
}
w[i] = ch; //restore w
}
}
}
vector<vector<string>> res;
if (found) {
vector<string> curr{endWord};
getPaths(endWord, beginWord, parents, curr, res);
}
return res;
}
bool findFile( const std::string& moduleName, const std::string& fileName, std::string& filePath )
{
std::string modulePath( moduleName );
OS::convertDotsToDirSeps( modulePath );
return OS::searchFile3( getPaths(),
Range<const std::string>( &modulePath, 1 ),
Range<const std::string>( &fileName, 1 ),
filePath );
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> ret;
if (root == NULL)
return ret;
vector<int> path;
getPaths(root, path, ret);
return ret;
}
/*
* Създава всички директории подадени в параметрите.
*/
void CommandPrompt::makeDirectory(string parameters){
/*
* Извличаме адресите и извикваме createNestedDirectories за всеки.
*/
queue<string> filePaths = getPaths(parameters);
while (!filePaths.empty()) {
createNestedDirectories(filePaths.front());
filePaths.pop();
}
}
CWiiSaveCrypted::CWiiSaveCrypted(const char* FileName, u64 TitleID)
: m_TitleID(TitleID)
{
Common::ReadReplacements(replacements);
strcpy(pathData_bin, FileName);
memcpy(SD_IV, "\x21\x67\x12\xE6\xAA\x1F\x68\x9F\x95\xC5\xA2\x23\x24\xDC\x6A\x98", 0x10);
if (!TitleID) // Import
{
AES_set_decrypt_key(SDKey, 128, &m_AES_KEY);
do
{
b_valid = true;
ReadHDR();
ReadBKHDR();
ImportWiiSaveFiles();
// TODO: check_sig()
if (b_valid)
{
SuccessAlertT("Successfully imported save files");
b_tryAgain = false;
}
else
{
b_tryAgain = AskYesNoT("Import failed, try again?");
}
} while(b_tryAgain);
}
else
{
AES_set_encrypt_key(SDKey, 128, &m_AES_KEY);
if (getPaths(true))
{
do
{
b_valid = true;
WriteHDR();
WriteBKHDR();
ExportWiiSaveFiles();
do_sig();
if (b_valid)
{
SuccessAlertT("Successfully exported file to %s", pathData_bin);
b_tryAgain = false;
}
else
{
b_tryAgain = AskYesNoT("Export failed, try again?");
}
} while(b_tryAgain);
}
}
}
void CWiiSaveCrypted::ReadHDR()
{
File::IOFile fpData_bin(encryptedSavePath, "rb");
if (!fpData_bin)
{
PanicAlertT("Cannot open %s", encryptedSavePath.c_str());
b_valid = false;
return;
}
if (!fpData_bin.ReadBytes(&_encryptedHeader, HEADER_SZ))
{
PanicAlertT("Failed to read header");
b_valid = false;
return;
}
fpData_bin.Close();
aes_crypt_cbc(&m_AES_ctx, AES_DECRYPT, HEADER_SZ, SD_IV, (const u8*)&_encryptedHeader, (u8*)&_header);
u32 bannerSize = Common::swap32(_header.hdr.BannerSize);
if ((bannerSize < FULL_BNR_MIN) || (bannerSize > FULL_BNR_MAX) ||
(((bannerSize - BNR_SZ) % ICON_SZ) != 0))
{
PanicAlertT("Not a Wii save or read failure for file header size %x", bannerSize);
b_valid = false;
return;
}
m_TitleID = Common::swap64(_header.hdr.SaveGameTitle);
u8 md5_file[16];
u8 md5_calc[16];
memcpy(md5_file, _header.hdr.Md5, 0x10);
memcpy(_header.hdr.Md5, MD5_BLANKER, 0x10);
md5((u8*)&_header, HEADER_SZ, md5_calc);
if (memcmp(md5_file, md5_calc, 0x10))
{
PanicAlertT("MD5 mismatch\n %016" PRIx64 "%016" PRIx64 " != %016" PRIx64 "%016" PRIx64, Common::swap64(md5_file),Common::swap64(md5_file+8), Common::swap64(md5_calc), Common::swap64(md5_calc+8));
b_valid= false;
}
if (!getPaths())
{
b_valid = false;
return;
}
std::string BannerFilePath = WiiTitlePath + "banner.bin";
if (!File::Exists(BannerFilePath) || AskYesNoT("%s already exists, overwrite?", BannerFilePath.c_str()))
{
INFO_LOG(CONSOLE, "Creating file %s", BannerFilePath.c_str());
File::IOFile fpBanner_bin(BannerFilePath, "wb");
fpBanner_bin.WriteBytes(_header.BNR, bannerSize);
}
}
void Circuit::getPaths(gate* g)//gets all paths in the circuit and prints them
{
Paths.push_back(g); // push this gate into the vector
if (Paths.size() > 1) PathDelay+=Paths[Paths.size()-2]->getDelay(); //add delay of previous gate
for(std::map<std::string, wire*>::iterator i = wireMap.begin(); i != wireMap.end(); i++)
if (i->second->getWSource()->getName() == g->getName())
for (int j = 0; j < i->second->getWDestionations().size(); j++)
getPaths(i->second->getWDestionations()[j]);
if ((g->getIsFlip() && !g->getFlipIn()) || g->getType() == "output") //if the gate is an output flipflop or normal output
printPaths(calcReqTime(g));
Paths.pop_back();
PathDelay-= g->getDelay();
}
//---------------------------------------------------------------------
myftw(char *pathname, Myfunc *func)
{
fprintf(stderr, "Searching for %s in: %s\n",ar.sval, pathname);
ar.pval = (char*)path_alloc(&pathlen);
/* malloc PATH_MAX+1 bytes */
if (pathlen <= strlen(pathname)) {
pathlen = strlen(pathname) * 2;
if ((ar.pval = realloc(ar.pval, pathlen)) == NULL)
fprintf(stderr, "%s\n", "Alloc failed");
}
strcpy(ar.pval, pathname);
return(getPaths(func));
}
/* START_OF_MAIN */
int main(int argc, char const *argv[]){
/*degiskenler*/
struct sigaction act;
char sPath[PATH_MAX];
FILE *fLogFilePtr;
DIR *dRootDirPtr;
int fd[2],
iPipeFirstValue = 0,
iResult = 0;
/* signal handler olustur*/
act.sa_handler = setdoneflag;
act.sa_flags = 0;
if ((sigemptyset(&act.sa_mask) == -1) || sigaction(SIGINT, &act, NULL) == -1) {
err_sys("Failed to set CTRL-C handler\n");
}
mainpid=getpid();
strcpy(sPath,argv[1]);
if(argc!=3)
usage("Please enter 3 command line arguments: <executable_file> <text_file> <target_word>");
if(isDirectory(sPath)==false || strlen(argv[1])>PATH_MAX)
usage("Please enter a correct path.");
if((dRootDirPtr = opendir(sPath)) == NULL)
usage("Can't open directory.");
closedir(dRootDirPtr);
/* log dosyasini ac */
fLogFilePtr=fopen(LOG_FILE, "a");
if(fLogFilePtr==NULL)
err_sys("opendir");
/*pipe olustur*/
if(pipe(fd)==-1)
err_sys("Failed to create the pipe.\n");
/*pipe'a ilk deger olarak 0 yaz ve pipe'i kapat*/
write(fd[1], &iPipeFirstValue, sizeof(int));
/*recursive fonksiyonu cagir*/
getPaths(sPath, argv[2], fd, fLogFilePtr);
/*toplam kelime sayisini pipe'tan oku ve pipe'i kapat*/
read(fd[0], &iResult, sizeof(int));
close(fd[0]);
close(fd[1]);
/*prompt*/
printf("\n'%s' iterates %d times in '%s'.\n", argv[2], iResult, sPath);
/*dosyayi kapat*/
fclose(fLogFilePtr);
return 0;
}
bool CubeAnim::initFmod()
{
FMOD_System_Create(&system);
FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, NULL);
getPaths(MUSIC_PATH);
if (_paths.size() == 0)
std::cout << "Error on loading" << std::endl;
else
{
_itp = _paths.begin();
if (loadSound(*_itp) == false)
return (false);
}
return (true);
}
Highscore::Highscore(GameType type) : type_(type), blink_(nullptr) {
switch (type) {
case GameType::NORMAL:
filename_ = getPaths().getConfig() + "normal.txt";
break;
case GameType::FIFTYLINES:
filename_ = getPaths().getConfig() + "fiftylines.txt";
break;
}
std::ifstream fin(filename_);
if(fin)
{
for(int i = 0; i < 5; ++i)
{
Data temp;
std::getline(fin, temp.name);
fin >> (temp.score) >> (temp.time);
highscores_.push_back(temp);
fin.ignore(3, '\n'); // Read till next \n
}
}
else
{
for(int i = 0; i < 5; ++i)
CWiiSaveCrypted::CWiiSaveCrypted(const char* FileName, u64 TitleID)
: m_TitleID(TitleID)
{
Common::ReadReplacements(replacements);
encryptedSavePath = std::string(FileName);
memcpy(SD_IV, "\x21\x67\x12\xE6\xAA\x1F\x68\x9F\x95\xC5\xA2\x23\x24\xDC\x6A\x98", 0x10);
if (!TitleID) // Import
{
aes_setkey_dec(&m_AES_ctx, SDKey, 128);
b_valid = true;
ReadHDR();
ReadBKHDR();
ImportWiiSaveFiles();
// TODO: check_sig()
if (b_valid)
{
SuccessAlertT("Successfully imported save files");
}
else
{
PanicAlertT("Import failed");
}
}
else
{
aes_setkey_enc(&m_AES_ctx, SDKey, 128);
if (getPaths(true))
{
b_valid = true;
WriteHDR();
WriteBKHDR();
ExportWiiSaveFiles();
do_sig();
if (b_valid)
{
SuccessAlertT("Successfully exported file to %s", encryptedSavePath.c_str());
}
else
{
PanicAlertT("Export failed");
}
}
}
}
//find paths from word to beginWord with parents
//grow path curr
void getPaths(const string& word,
const string& beginWord,
const unordered_map<string, vector<string>>& parents,
vector<string>& curr,
vector<vector<string>>& ans) {
if (word == beginWord) { //curr path reaches beginWord, curr: end -> beginWord
//use curr to create new path, copy/clone, since curr will continue change
ans.push_back(vector<string>(curr.rbegin(), curr.rend()));
return;
}
for (const string& p : parents.at(word)) { //accepted
//for (const string& p: parents[word]) { //error
curr.push_back(p);// try each parent
//recur with p, curr
getPaths(p, beginWord, parents, curr, ans);
curr.pop_back(); //backtracking
}
}
void RoadNavigation::planRoadDetection(const nav_msgs::Path::ConstPtr& lane_traj, const geometry_msgs::PoseWithCovarianceStamped::ConstPtr& pose) {
nav_msgs::Path target_traj = decideTargetTrajectory(lane_traj);
geometry_msgs::Pose current_pose = pose->pose.pose;
std::vector<geometry_msgs::Pose> targets = getTargets(current_pose, target_traj);
std::vector<std::vector<PathSegment*> > paths = getPaths(current_pose, targets);
if (paths.size() == 0) {
ROS_WARN("[local_planner]: No path found");
return;
}
// nav_msgs::Path best_path;
// for (int i = 0; i < paths.size(); i++) {
// // TODO: Choose the best path
// best_path = paths[0];
// }
//
// best_path.header.stamp = ros::Time::now();
// return best_path;
}
/*
* Извежда метаданните на всички файлове в параметрите.
*/
void CommandPrompt::getFileMetadata(string parameters){
/*
* Ако няма параметри извежда метаданните на текущата директория.
*/
if (parameters.empty()) {
currentDir->printMeta();
return;
}
/*
* Извлича адресите от параметрите и за всеки намира директорията или файла
*/
queue<string> dirPaths = getPaths(parameters);
TextFile* file;
while (!dirPaths.empty()) {
file = this->determinePathAndGetFile(dirPaths.front());
if (file != NULL)
file->printMeta();
dirPaths.pop();
}
}
void BinaryPLYArchiLidarFileIO::loadData(LidarDataContainer& lidarContainer, std::string filename)
{
getPaths(lidarContainer,filename);
// BV: very subtle problem: windows endlines are counted double in ascii (\R\N), but not in binary (0a)
// so under windows there will be a shift between ascii and binary positions
// My solution: we get the data size from the lidarContainer and get the end header position from end of file based on it
std::ifstream ply_ifs(m_data_path.c_str(), std::ios::binary);
if(!ply_ifs.good()) throw std::logic_error(std::string(__FUNCTION__) + ": Failed to open " + m_data_path +"\n");
ply_ifs.seekg(0, std::ios::end);
const int dataSize = lidarContainer.size()*lidarContainer.pointSize();
if(ply_ifs.tellg() < dataSize)
{
std::ostringstream oss;
oss << "BinaryPLYArchiLidarFileIO::loadData: binary file size " << ply_ifs.tellg() << "< what xml expects: " << dataSize << std::endl;
oss << "lidarContainer.size()=" << lidarContainer.size() << ", lidarContainer.pointSize()=" << lidarContainer.pointSize() << std:: endl;
throw std::logic_error(oss.str());
}
ply_ifs.seekg(-dataSize, std::ios::end);
//std::cout << "Binary part starts at " << fileInBin.tellg() << std::endl;
// lidarContainer.allocate(lidarMetaData.nbPoints_); // BV: do we need that ? works well without
ply_ifs.read(lidarContainer.rawData(), dataSize);
}
static void runClassifier(const std::string& outputFilename,
const std::string& inputFileNames, const std::string& modelFileName,
bool shouldClassify, bool shouldTrain, bool shouldLearnFeatures, bool shouldExtractFeatures)
{
util::log("minerva-classifier") << "Loading classifier.\n";
classifiers::ClassifierEngine* engine = nullptr;
try
{
checkInputs(inputFileNames, modelFileName, shouldClassify,
shouldTrain, shouldLearnFeatures, shouldExtractFeatures);
engine = createEngine(outputFilename, shouldClassify, shouldTrain,
shouldLearnFeatures, shouldExtractFeatures);
if(engine == nullptr)
{
throw std::runtime_error("Failed to create classifier engine.");
}
engine->loadModel(modelFileName);
engine->runOnPaths(getPaths(inputFileNames));
engine->reportStatistics(std::cout);
delete engine;
}
catch(const std::exception& e)
{
std::cout << "Minerva Classifier Failed:\n";
std::cout << "Message: " << e.what() << "\n\n";
delete engine;
}
}
