int AclReader::read(const std::string& fn, boost::shared_ptr<AclData> d) {
fileName = fn;
lineNumber = 0;
char buff[1024];
std::ifstream ifs(fn.c_str(), std::ios_base::in);
if (!ifs.good()) {
errorStream << "Unable to open ACL file \"" << fn << "\": eof=" << (ifs.eof()?"T":"F") << "; fail=" << (ifs.fail()?"T":"F") << "; bad=" << (ifs.bad()?"T":"F");
return -1;
}
// Propagate nonzero per-user max connection setting from CLI
if (cliMaxConnPerUser > 0) {
connQuotaRulesExist = true;
(*connQuota)[AclData::ACL_KEYWORD_ALL] = cliMaxConnPerUser;
}
// Propagate nonzero per-user max queue setting from CLI
if (cliMaxQueuesPerUser > 0) {
queueQuotaRulesExist = true;
(*queueQuota)[AclData::ACL_KEYWORD_ALL] = cliMaxQueuesPerUser;
}
// Loop to process the Acl file
try {
bool err = false;
while (ifs.good()) {
ifs.getline(buff, 1024);
lineNumber++;
if (std::strlen(buff) > 0 && buff[0] != '#') // Ignore blank lines and comments
err |= !processLine(buff);
}
if (!ifs.eof())
{
errorStream << "Unable to read ACL file \"" << fn << "\": eof=" << (ifs.eof()?"T":"F") << "; fail=" << (ifs.fail()?"T":"F") << "; bad=" << (ifs.bad()?"T":"F");
ifs.close();
return -2;
}
ifs.close();
if (err) return -3;
QPID_LOG(notice, "ACL: Read file \"" << fn << "\"");
} catch (const std::exception& e) {
errorStream << "Unable to read ACL file \"" << fn << "\": " << e.what();
ifs.close();
return -4;
} catch (...) {
errorStream << "Unable to read ACL file \"" << fn << "\": Unknown exception";
ifs.close();
return -5;
}
printNames();
printRules();
printQuotas(AclData::ACL_KEYWORD_QUOTA_CONNECTIONS, connQuota);
printQuotas(AclData::ACL_KEYWORD_QUOTA_QUEUES, queueQuota);
loadDecisionData(d);
return 0;
}
/**
* @brief Prints the rules table which is stored in the rules table attribute.
*
* @return TRUE for success, FALSE for failure.
*/
Bool showRules(void)
{
int rulesTableAttrFile = 0;
char * rulesBuffer = NULL;
ssize_t bytesRead = 0;
/* Allocating memory for the rules table buffer */
rulesBuffer = malloc(PAGE_SIZE);
if (rulesBuffer == NULL)
{
printf("Failed allocating memory for the rules table buffer.\n");
return FALSE;
}
/* Opening the rules table attribute file */
rulesTableAttrFile = open(RULES_TABLE_ATTR_PATH, O_RDONLY);
if (rulesTableAttrFile == -1)
{
printf("Error in opening the rules table attribute file for read: %s\n", strerror(errno));
free(rulesBuffer);
return FALSE;
}
/* Reading the rules table buffer */
bytesRead = read(rulesTableAttrFile, (void *)rulesBuffer, PAGE_SIZE - 1);
if (bytesRead == -1)
{
printf("Error in reading from the rules table attribute file: %s\n", strerror(errno));
close(rulesTableAttrFile);
free(rulesBuffer);
return FALSE;
}
close(rulesTableAttrFile);
/* Printing the rules */
printRules(rulesBuffer);
free(rulesBuffer);
return TRUE;
}
State onMainMenu(Game* game) {
int choice = 0;
char cmd[255];
char userInput[255];
cmd[0] = 0;
/* Print initial Main Menu */
printMainMenu(game);
/* get choices: Possible choices are New Game, Load Game, Set up board, How to play */
choice = getInput();
/* Added by Cesar 1/26/2014 */
/* handling the cases mentioned above */
switch(choice){
case 0:
/* Start a new game */
return NewGame;
case 1:
/* Load an old game */
printf("Enter the file name you want to load: ");
scanf("%s", userInput);
printf("\n");
fseek(stdin,0,SEEK_END);
loadGame(game, userInput);
return NewGame;
case 2:
/* Setup custom board */
while(cmd[0]!='0')
{
/*
printf("Enter the file name you want to save \n");
scanf("%s", userInput);
saveLog(game, userInput);
fseek(stdin,0,SEEK_END);
*/
printBoard(game);
printf("Please input move to move piece (input 0 to start game): ");
getGameInput(cmd);
printf("\n");
directMoveNotation(game, cmd);
}
return NewGame;
case 3:
/* How to play */
printRules();
return MainMenu;
case 4:
/* Reset board/game */
resetGame(game);
printf("Board/game has been reset.\n\n");
return MainMenu;
case 5:
/* displays help */
help();
return MainMenu;
case 9:
return Exit;
default:
return MainMenu;
}
/* end code added by Cesar */
/* old code, commented out on 1/26/2014
switch(choice) {
case 0:
return NewGame;
case 1:
loadGame(game);
return NewGame;
case 2:
game->setting->allowRedo ^= 1;
return MainMenu;
case 3:
game->setting->allowIllegalMove ^= 1;
return MainMenu;
case 4:
selectOpponent(game);
return MainMenu;
case 5:
selectDifficulty(game);
return MainMenu;
case 6:
return Exit;
default:
return MainMenu;
}
End old code */
}
int main(){
std::cout<<"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * "<<std::endl;
std::cout<<"Ce programme permettra de réaliser des opérations floues sur une base de faits et une base de règles à l'aide d'un fuzzifier"<<std::endl;
std::cout<<"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * "<<std::endl;
std::cout<<" "<<std::endl;
char* filename;
//std::cout<<"Entrer le nom d'un fichier texte à analyser pour créer la base de faits"<<std::endl;
//std::cin>>filename;
//std::cout<<"Génération de la base de faits à base du fichier texte spécifié ... "<<std::endl;
//on parse les fichiers texte
std::vector<Fait> Faits = Parser_faits("faits.txt");
//on parse les regeles
std::vector<Rule> Rules = Parser_rules("rules.txt");
//update de la base de faits en prenant en compte la base de rules (MAJ de l'énoncé)
Faits = updateFaits(Faits, Rules);
//fonction MAJ1 de l'énoncé: créé la liste des métarègles et update les faits avec la
// std::vector<Rule> MetaRules = updateMeta(Faits, Rules);
// on verra plus tard pour les metaregles
//check à l'écran la base de faits
printFaits(Faits);
sleep(5);
printRules(Rules);
sleep(5);
//on créé notre matrice de transition entre les valeurs :
// AB B TB
// AB 1 1 1
// B 0.7 1 1
// TB 0.3 0.8 1
std::vector<std::vector<double>> TransMatrix = {{1.,1.,1.},{0.7,1.,1.},{0.3,0.8,1.}};
// Créer la liste de conclusion à évaluer
std::vector<EvalConcl> EvalConcls = EvalFunction(Faits, Rules, TransMatrix);
std::cout << "Travail de fuzzification en cours ..." << std::endl;
sleep(5);
std::cout<< "Affiche des conclusions et de leur évaluations: "<<std::endl;
std::cout<< "************************************************" << std::endl;
//Affichage des conclusions évaluées
for(std::vector<EvalConcl>::iterator ite=EvalConcls.begin();ite!=EvalConcls.end();++ite){
std::cout<<"Conclusion :"<<std::get<0>(ite->first)<<std::endl;
std::cout<<"Et l'évaluation pour cette conclusion est : " << ite->second << std::endl;
std::cout<< " " << std::endl;
}
//on créé nos vecteurs de valeur de fait
double listB[] = {0.001,0.005,0.005,0.01,0.1,0.3,0.4,0.6,0.8,0.9,1.0};
std::vector<double> uB (11);
std::vector<double> uTB(11);
uB[0]=0.001;
uB[1]=0.005;
uB[2]=0.005;
uB[3]=0.01;
uB[4]=0.1;
uB[5]=0.3;
uB[6]=0.4;
uB[7]=0.6;
uB[8]=0.8;
uB[9]=0.9;
uB[10]=1.0;
//it=uTB.begin(;)
for( std::vector<double>::iterator it = uB.begin() ; it != uB.end(); ++it){
double value = *it;
uTB.push_back(value*value);
//std::cout<<uTB.back()<<std::endl;
}
/*
std::tuple<std::string, std::string, double> line;
std::vector<std::tuple<std::string, std::string, double>> parsed_file;
parsed_file.emplace_back("test","test",0);
std::cout<< std::get<0>(parsed_file[0]) << std::get<1>(parsed_file[0]) << std::get<2>(parsed_file[0]) << std::endl ;
*/
return 0;
}
Transformer::Transformer(string configFilename, bool showRules)
{
// load configuration file
cerr << "Loading configuration file: ";
loadConfig(configFilename);
cerr << "done" << endl;
string line;
// import binary rules
if (rules2Filename.length() > 0)
{
cerr << "Loading binary rules: ";
if (baseDir != "") rules2Filename = baseDir + "/" + rules2Filename;
ifstream rules2File(rules2Filename.c_str());
if (!rules2File) printError("binary rules file `" + rules2Filename + "' could not be found");
ruleCount = 0;
while (getline(rules2File, line))
{
if (line[0] != '%')
{
loadRule(line, 2);
if (ruleCount % 10000 == 0) cerr << '.'; // progress meter
}
}
cerr << ' ' << ruleCount << " binary rules loaded" << endl;
rules2File.close();
useRules2 = true; // enable binary rules
}
// import 3+-ary rules
if (rules3plusFilename.length() > 0)
{
cerr << "Loading 3+-ary rules: ";
if (baseDir != "") rules3plusFilename = baseDir + "/" + rules3plusFilename;
ifstream rules3plusFile(rules3plusFilename.c_str());
if (!rules3plusFile) printError("3+-ary rules file `" + rules3plusFilename + "' could not be found");
ruleCount = 0;
while (getline(rules3plusFile, line))
{
if (line[0] != '%')
{
loadRule(line, 3);
if (ruleCount % 10000 == 0) cerr << '.'; // progress meter
}
}
cerr << ' ' << ruleCount << " 3+-ary rules loaded" << endl;
rules3plusFile.close();
useRules3plus = true; // enable 3+-ary rules
}
if (showRules)
{
cout << "[BINARY RULES]" << endl;
printRules(2);
cout << endl;
cout << "[3+-ARY RULES]" << endl;
printRules(3);
cout << endl;
}
}
