void Data::deleteClasses(const QList<QString> &ids)
{
int n = ids.size();
if (n <= 0) return;
if (this->m_modifyReply) delete this->m_modifyReply;
QUrl url = QUrl("http://szektam2.byethost3.com/deleteClasses.php");
PARAMS params;
params.addQueryItem("username", Key::username());
params.addQueryItem("password", Key::password());
params.addQueryItem("n", QString::number(n));
for (int i = 0; i < n; ++i) {
params.addQueryItem(QString("id%1").arg(i), ids[i]);
}
QByteArray data;
#if QT5
data.append(params.toString());
url.setQuery(params);
#else
data.append(params.encodedQuery());
#endif
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
this->m_modifyReply = this->m_manager->post(request, data);
connect(this->m_modifyReply, SIGNAL(finished()), this, SLOT(getClasses()));
}
void Data::insertClass(const QString &className, int number, int teacher)
{
if (this->m_insertReply) delete this->m_insertReply;
QUrl url = QUrl("http://szektam2.byethost3.com/insertClass.php");
PARAMS params;
params.addQueryItem("username", Key::username());
params.addQueryItem("password", Key::password());
params.addQueryItem("className", className);
params.addQueryItem("number", QString::number(number));
params.addQueryItem("teacher", QString::number(teacher));
QByteArray data;
#if QT5
data.append(params.toString());
url.setQuery(params);
#else
data.append(params.encodedQuery());
#endif
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
this->m_insertReply = this->m_manager->post(request, data);
connect(this->m_insertReply, SIGNAL(finished()), this, SLOT(getClasses()));
//connect(this->m_insertReply, SIGNAL(finished()), this, SLOT(readReady()));
}
void FileScope::getScopesSet(BlockScopeRawPtrQueue &v) {
for (const auto& clsVec : getClasses()) {
for (const auto cls : clsVec.second) {
if (cls->getStmt()) {
v.push_back(cls);
getFuncScopesSet(v, cls->getFunctions());
}
}
}
getFuncScopesSet(v, getFunctions());
if (const auto redec = m_redeclaredFunctions) {
for (const auto& funcVec : *redec) {
auto i = funcVec.second.begin(), e = funcVec.second.end();
v.insert(v.end(), ++i, e);
}
}
}
bool CSMWorld::Data::hasId (const std::string& id) const
{
return
getGlobals().searchId (id)!=-1 ||
getGmsts().searchId (id)!=-1 ||
getSkills().searchId (id)!=-1 ||
getClasses().searchId (id)!=-1 ||
getFactions().searchId (id)!=-1 ||
getRaces().searchId (id)!=-1 ||
getSounds().searchId (id)!=-1 ||
getScripts().searchId (id)!=-1 ||
getRegions().searchId (id)!=-1 ||
getBirthsigns().searchId (id)!=-1 ||
getSpells().searchId (id)!=-1 ||
getTopics().searchId (id)!=-1 ||
getJournals().searchId (id)!=-1 ||
getCells().searchId (id)!=-1 ||
getReferenceables().searchId (id)!=-1;
}
void Data::deleteAllClasses()
{
if (this->m_modifyReply) delete this->m_modifyReply;
QUrl url = QUrl("http://szektam2.byethost3.com/deleteAllClasses.php");
PARAMS params;
params.addQueryItem("username", Key::username());
params.addQueryItem("password", Key::password());
QByteArray data;
#if QT5
data.append(params.toString());
url.setQuery(params);
#else
data.append(params.encodedQuery());
#endif
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
this->m_modifyReply = this->m_manager->post(request, data);
connect(this->m_modifyReply, SIGNAL(finished()), this, SLOT(getClasses()));
}
void JNIClassBase::releaseAllClasses (JNIEnv* env)
{
const Array<JNIClassBase*>& classes = getClasses();
for (int i = classes.size(); --i >= 0;)
classes.getUnchecked(i)->release (env);
}
JNIClassBase::~JNIClassBase()
{
getClasses().removeFirstMatchingValue (this);
}
JNIClassBase::JNIClassBase (const char* cp) : classPath (cp), classRef (0)
{
getClasses().add (this);
}
/*Command line entry point of the program*/
int main (int argc, char* argv[]){
/*getopt() variables */
int opt;
char* optarg_dup = NULL;
/*Command line options*/
uchar cflg=0,gflg=0,kflg=0,lflg=0,mflg=0,oflg=0, sflg=0;
uchar pflg=0,tflg=0,vflg=0,xflg=0,zflg=0;
InputParams* inputParams = NULL;
/*Working variables */
int i,m;
int nbPriors;
int nbNodes;
int nbClass;
int nbLabeled;
int nbUnlabeled;
int nbSimParams;
int actualWlen;
int start_cpu,stop_cpu;
real tmp;
uchar* absorbing = NULL;
char* labels = NULL;
char* featLabels = NULL;
char* targets = NULL;
char* preds = NULL;
int** classes = NULL;
real** N = NULL;
real* gram = NULL;
real** latF = NULL;
real** latB = NULL;
real** kernel = NULL;
SparseMatrix* spmat = NULL;
SparseMatrix* dataset = NULL;
DataStat* graphStat = NULL;
DataStat* featuresStat = NULL;
DWInfo* dwInfo = NULL;
OptiLen* optiLen = NULL;
PerfMeasures* unlabeledPerf = NULL;
LSVMDataInfo* dataInfo = NULL;
/*Print the program banner*/
printBanner();
/*Scan the command line*/
inputParams = malloc(sizeof(InputParams));
init_InputParams(inputParams);
while ((opt = getopt(argc,argv,"c:g:l:xms:k:o:p:rt:v:z:h")) != EOF){
switch(opt){
case 'c':
cflg++;
inputParams->nbFolds = atoi(optarg);
break;
case 'g':
gflg++;
inputParams->graphFname = (char*)malloc(FNAME_LEN*sizeof(char));
strncpy(inputParams->graphFname,optarg,FNAME_LEN);
break;
case 'k':
kflg++;
inputParams->gramFname = (char*)malloc(FNAME_LEN*sizeof(char));
strncpy(inputParams->gramFname,optarg,FNAME_LEN);
break;
case 's':
sflg++;
optarg_dup = (char*)__strdup(optarg);
nbSimParams = getNbTokens(optarg,",");
inputParams->simParams = vec_alloc(nbSimParams+1);
tokenizeReals(optarg_dup,",",inputParams->simParams);
break;
case 'l':
lflg++;
inputParams->wlen = atoi(optarg);
break;
case 'm':
mflg++;
break;
case 'o':
oflg++;
inputParams->outFname = (char*)malloc(FNAME_LEN*sizeof(char));
strncpy(inputParams->outFname,optarg,FNAME_LEN);
inputParams->outPRED = (char*)malloc(FNAME_LEN*sizeof(char));
inputParams->outLEN = (char*)malloc(FNAME_LEN*sizeof(char));
addExtension(inputParams->outFname,"pred",inputParams->outPRED);
addExtension(inputParams->outFname,"len",inputParams->outLEN);
break;
case 'p':
pflg++;
optarg_dup = (char*)__strdup(optarg);
nbPriors = getNbTokens(optarg,"#");
inputParams->priors = vec_alloc(nbPriors+1);
tokenizeReals(optarg_dup,"#",inputParams->priors);
break;
case 't':
tflg++;
inputParams->tarFname = (char*)malloc(FNAME_LEN*sizeof(char));
strncpy(inputParams->tarFname,optarg,FNAME_LEN);
break;
case 'v':
vflg++;
inputParams->verbose = atoi(optarg);
break;
case 'x':
xflg++;
inputParams->crossWalks = 1;
break;
case 'z':
zflg++;
inputParams->cvSeed = atoi(optarg);
break;
case 'h':
printHelp();
exit(EXIT_FAILURE);
break;
}
}
/*Check mandatory arguments*/
if(!gflg || !lflg || (!oflg && !mflg)){
fprintf(stderr,"Mandatory argument(s) missing\n");
printHelp();
exit(EXIT_FAILURE);
}
if( (kflg && !sflg) || (!kflg && sflg)){
fprintf(stderr, "Error with 'k' and 's' parameters\n");
printHelp();
exit(EXIT_FAILURE);
}
/*Check that the walk length is greater than 2*/
if(inputParams->wlen < 2){
fprintf(stderr,"The walkLen must be >= 2\n");
exit(EXIT_FAILURE);
}
/*Check that there are the right number of similarity parameters*/
if (kflg && sflg){
if(inputParams->simParams){
switch((int)inputParams->simParams[1]){
case 1 :
if((int)inputParams->simParams[0] != 1){
fprintf(stderr,"The similarity type 1 must have no parameters\n");
exit(EXIT_FAILURE);
}
break;
case 2 :
if((int)inputParams->simParams[0] != 2){
fprintf(stderr,"The similarity type 2 must have exactly 1 parameter\n");
exit(EXIT_FAILURE);
}
break;
case 3 :
if((int)inputParams->simParams[0] != 4){
fprintf(stderr,"The similarity type 3 must have exactly 3 parameters\n");
exit(EXIT_FAILURE);
}
break;
case 4 :
if((int)inputParams->simParams[0] != 2){
fprintf(stderr,"The similarity type 4 must have exactly 1 parameter\n");
exit(EXIT_FAILURE);
}
break;
default :
fprintf(stderr,"Unrecognized similarity type\n");
exit(EXIT_FAILURE);
}
}
}
/*Get the number of nodes in the graph*/
nbNodes = readNbNodes(inputParams->graphFname);
/*Get the number of distinct classes*/
nbClass = readNbClass(inputParams->graphFname);
/*Get info from the LIBSVM data*/
if (kflg){
dataInfo = malloc(sizeof(LSVMDataInfo));
getLSVMDataInfo(inputParams->gramFname,dataInfo);
dataset = spmat_alloc(dataInfo->nbLines,dataInfo->nbFeatures,0);
init_SparseMat(dataset);
featuresStat = DataStat_alloc(dataInfo->nbClass);
featLabels = char_vec_alloc(nbNodes);
}
/*Check if the number of nodes does not exceed the limitation*/
if(nbNodes > MAX_NODES){
fprintf(stderr,"This version is limited to maximum %i nodes\n",MAX_NODES);
exit(EXIT_FAILURE);
}
/*Check that the number of classes is lower than 128*/
if(nbClass > 127){
fprintf(stderr,"The number of classes must be <= 127\n");
exit(EXIT_FAILURE);
}
/*Check that the number of folds is between 2 and nbNodes*/
if(cflg){
if(inputParams->nbFolds == 1 || inputParams->nbFolds > nbNodes){
fprintf(stderr,"The number of folds must be > 1 and <= number of nodes\n");
exit(EXIT_FAILURE);
}
}
/*Allocate data structure*/
latF = mat_alloc(inputParams->wlen+1,nbNodes);
latB = mat_alloc(inputParams->wlen+1,nbNodes);
kernel = mat_alloc(nbNodes, nbNodes);
classes = (int**)malloc(sizeof(int*)*(nbClass+1));
labels = char_vec_alloc(nbNodes);
absorbing = uchar_vec_alloc(nbNodes);
if(kflg) gram = vec_alloc((nbNodes*(nbNodes+1))/2);
dwInfo = malloc(sizeof(DWInfo));
dwInfo->mass_abs = vec_alloc(nbClass);
spmat = spmat_alloc(nbNodes,nbNodes,1);
graphStat = DataStat_alloc(nbClass+1);
optiLen = malloc(sizeof(OptiLen));
/*Initialize the sparse transition matrix and the dataset if required*/
init_SparseMat(spmat);
/*Read the adjacency matrix*/
readMat(inputParams->graphFname,spmat,labels,graphStat,inputParams->verbose);
isSymmetric(spmat);
/*Get the indices of the nodes in each class */
getClasses(labels,nbNodes,classes,nbClass);
/*Get the number of labeled nodes*/
nbUnlabeled = classes[0][0];
nbLabeled = nbNodes - nbUnlabeled;
/*If provided, check that the priors match the number of classes*/
if(pflg){
if(nbClass != nbPriors){
printf("The number of priors does not match with the number of classes\n");
exit(EXIT_FAILURE);
}
/*Check that the priors sum up to 1*/
else{
tmp=0.0;
for(i=1;i<=inputParams->priors[0];i++){
tmp += inputParams->priors[i];
}
if(ABS(tmp-1.0) > PROB_EPS){
textcolor(BRIGHT,RED,BLACK);
printf("WARNING: The class priors do not sum up to 1\n");
textcolor(RESET,WHITE,BLACK);
}
}
}
/*If no priors provided, use empirical priors */
else{
inputParams->priors = vec_alloc(nbClass+1);
inputParams->priors[0] = (real)nbClass;
tmp = 0.0;
for(i=1;i<=inputParams->priors[0];i++)
tmp += graphStat->classCount[i];
for(i=1;i<=inputParams->priors[0];i++)
inputParams->priors[i] = (real)graphStat->classCount[i]/tmp;
}
/*If provided read the LIBSVM feature matrix*/
if(kflg){
m = readLSVMData(inputParams->gramFname,dataInfo,dataset,featLabels,featuresStat,inputParams->verbose);
if (dataInfo->nbLines != nbNodes){
fprintf(stderr,"Number of line on the LIBSVM (%i) file doesn't match the number of nodes (%i)\n", dataInfo->nbLines, nbNodes);
exit(EXIT_FAILURE);
}
/* Multiply a kernel matrix based on the dataset*/
/* TO DO : define a parameters to lower the importance of the features*/
buildKernel2(spmat, dataset, 0.1, inputParams);
/*Multiply adjacency matrix*/
}
/*Print statistics about the graph, classes, and run-mode*/
if (inputParams->verbose > 0)
printInputInfo(spmat,graphStat,nbClass,inputParams);
/*Minimum Covering Length mode*/
if (mflg){
computeMCL(spmat,absorbing,labels,classes,nbClass,latF,latB,inputParams);
/*Exit after displaying the statistics*/
exit(EXIT_SUCCESS);
}
/*Start the CPU chronometer*/
start_cpu = clock();
/*If required tune the maximum walk length by cross-validation*/
if(cflg){
crossValidateLength(spmat,absorbing,labels,classes,nbClass,NULL,latF,latB,inputParams,optiLen);
actualWlen = optiLen->len;
}
/*Otherwise use the prescribed length*/
else
actualWlen = inputParams->wlen;
/************************ALGORITHM STARTS HERE****************************/
if(inputParams->verbose >= 1){
textcolor(BRIGHT,RED,BLACK);
printf("Performing discriminative walks up to length %i on full data\n",actualWlen);
textcolor(RESET,WHITE,BLACK);
}
/*Allocate data structure*/
N = mat_alloc(nbUnlabeled,nbClass);
preds = char_vec_alloc(nbUnlabeled);
init_mat(N,nbUnlabeled,nbClass);
/*Launch the D-walks*/
dwalk(spmat,absorbing,classes,nbClass,N,latF,latB,actualWlen,inputParams->crossWalks,dwInfo,inputParams->verbose);
/************************ALGORITHM STOPS HERE****************************/
/*Stop the CPU chronometer*/
stop_cpu = clock();
/*Compute the predictions as the argmax on classes for each unlabeled node*/
computePredictions(N,preds,inputParams->priors,nbUnlabeled,nbClass);
/*Write the model predictions*/
writePredictions_unlabeled(inputParams->outPRED,preds,N,nbClass,classes[0]);
/*Write the class betweeness */
/*If a target file is provided compare predictions and targets*/
if(tflg){
unlabeledPerf = PerfMeasures_alloc(nbClass+1);
computeUnlabeledPerf(preds,classes[0],nbUnlabeled,nbClass,inputParams,unlabeledPerf,inputParams->verbose);
free_PerfMeasures(unlabeledPerf,nbClass+1);
}
/*Print informations*/
if (inputParams->verbose >= 1){
for(i=0;i<nbClass;i++)
printf("Exploration rate in class %2i : %1.2f %%\n",i+1,100*dwInfo->mass_abs[i]);
printf("CPU Time (sec) : %1.4f\n",((double)(stop_cpu - start_cpu)/CLOCKS_PER_SEC));
printLineDelim();
}
/*Optionally release memory here*/
#ifdef FREE_MEMORY_AT_END
free_classes(classes,nbClass+1);
free_InputParams(inputParams);
free_DataStat(graphStat);
free_DWInfo(dwInfo);
free(absorbing);
free(labels);
free_mat(N,nbUnlabeled);
free_mat(latF,inputParams->wlen+1);
free_mat(latB,inputParams->wlen+1);
free_SparseMatrix(spmat);
free(optiLen);
free(preds);
if(kflg) free(gram);
#endif
/*Exit successfully :-)*/
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
//Command line arguments
TCLAP::CmdLine cmd("GOBLET (c) 2012, International Livestock Research Institute (ILRI) \n Developed by Carlos Quiros ([email protected])", ' ', "1.0 (Beta 1)");
//Required arguments
TCLAP::ValueArg<std::string> databaseArg("d","database","Database name",true,"","string");
TCLAP::ValueArg<std::string> datasetArg("t","dataset","Dataset name",true,"","string");
TCLAP::ValueArg<std::string> classArg("c","classdefinition","Class definition: 'ClassNumber:valueFrom ValueTo,ClassNumber:valueFrom ValueTo,...'",true,"","string");
//Non required arguments
TCLAP::ValueArg<std::string> pathArg("a","path","Path to database. Default .",false,".","string");
TCLAP::ValueArg<std::string> hostArg("H","host","Connect to host. Default localhost",false,"localhost","string");
TCLAP::ValueArg<std::string> portArg("P","port","Port number to use. Default 3306",false,"3306","string");
TCLAP::ValueArg<std::string> userArg("u","user","User. Default empty",false,"","string");
TCLAP::ValueArg<std::string> passArg("p","password","Passwork. Default no password",false,"","string");
TCLAP::ValueArg<std::string> extentArg("e","extent","Extent: '(upperLeft degrees lat,log) (lowerRight degrees lat,log)'",false,"","string");
TCLAP::ValueArg<std::string> shpConstraintArg("S","constraintbyshapes","Constraint classification using shapes: ShapeDataSet:shapeID,ShapeID,....",false,"","string");
TCLAP::ValueArg<std::string> defValArg("v","defaultvalue","Default value 0",false,"0","string");
//Switches
TCLAP::SwitchArg remoteSwitch("r","remote","Connect to remote host", cmd, false);
cmd.add(databaseArg);
cmd.add(datasetArg);
cmd.add(classArg);
cmd.add(extentArg);
cmd.add(shpConstraintArg);
cmd.add(pathArg);
cmd.add(hostArg);
cmd.add(portArg);
cmd.add(userArg);
cmd.add(passArg);
cmd.add(defValArg);
//Parsing the command lines
cmd.parse( argc, argv );
//Getting the variables from the command
bool remote = remoteSwitch.getValue();
QString path = QString::fromUtf8(pathArg.getValue().c_str());
QString dbName = QString::fromUtf8(databaseArg.getValue().c_str());
QString host = QString::fromUtf8(hostArg.getValue().c_str());
QString port = QString::fromUtf8(portArg.getValue().c_str());
QString userName = QString::fromUtf8(userArg.getValue().c_str());
QString password = QString::fromUtf8(passArg.getValue().c_str());
QString tableName = QString::fromUtf8(datasetArg.getValue().c_str());
QString classDef = QString::fromUtf8(classArg.getValue().c_str());
QString extent = QString::fromUtf8(extentArg.getValue().c_str());
QString shapes = QString::fromUtf8(shpConstraintArg.getValue().c_str());
QString defvalue = QString::fromUtf8(defValArg.getValue().c_str());
myDBConn con;
QSqlDatabase mydb;
if (!remote)
{
QDir dir;
dir.setPath(path);
if (con.connectToDB(dir.absolutePath()) == 1)
{
if (!dir.cd(dbName))
{
gbtLog(QObject::tr("The database does not exists"));
con.closeConnection();
return 1;
}
mydb = QSqlDatabase::addDatabase(con.getDriver(),"connection1");
}
}
else
{
mydb = QSqlDatabase::addDatabase("QMYSQL","connection1");
mydb.setHostName(host);
mydb.setPort(port.toInt());
if (!userName.isEmpty())
mydb.setUserName(userName);
if (!password.isEmpty())
mydb.setPassword(password);
}
mydb.setDatabaseName(dbName);
if (!mydb.open())
{
gbtLog(QObject::tr("Cannot open database"));
con.closeConnection();
return 1;
}
else
{
QTime procTime;
procTime.start();
//We need to check if dataset is a grid
getClasses(classDef);
if (classes.count() ==0 )
{
gbtLog(QObject::tr("There are no classes!"));
mydb.close();
con.closeConnection();
return 1;
}
QString sql;
QString headsql;
headsql = "UPDATE " + tableName + " TA";
QString WhereClause;
sql = " SET TA.classCode = CASE";
for (int t=0; t <= classes.count()-1;t++)
{
sql = sql + " WHEN (TA.cellvalue >= " + QString::number(classes[t].from,'f',5);
sql = sql + " AND TA.cellvalue <= " + QString::number(classes[t].to,'f',5);
sql = sql + ") THEN " + QString::number(classes[t].classNumber);
}
sql = sql + " ELSE " + defvalue + " END";
if (!extent.isEmpty())
{
WhereClause = getWhereClauseFromExtent(extent,mydb,tableName);
if (!WhereClause.isEmpty())
sql = sql + " WHERE " + WhereClause;
}
QSqlQuery qry(mydb);
if (!shapes.isEmpty())
{
QString shapeClause;
shapeClause = getShapeClause(shapes,mydb);
if (!shapeClause.isEmpty())
{
//
QString sqlcreate;
sqlcreate = "CREATE TEMPORARY TABLE tmpshapes (";
sqlcreate = sqlcreate + "geokey VARCHAR(14) NOT NULL ,";
sqlcreate = sqlcreate + "PRIMARY KEY (geokey))";
sqlcreate = sqlcreate + " ENGINE = MyISAM";
if (qry.exec(sqlcreate))
{
QString extentClause;
extentClause = WhereClause;
extentClause.replace("TA.","");
if (!extentClause.isEmpty())
sqlcreate = "INSERT INTO tmpshapes " + shapeClause + " AND " + extentClause;
else
sqlcreate = "INSERT INTO tmpshapes " + shapeClause;
gbtLog(QObject::tr("Preselecting shapes"));
if (qry.exec(sqlcreate))
{
headsql = headsql + ", tmpshapes TB";
if (sql.contains("WHERE"))
sql = sql + " AND TA.geokey = TB.geokey";
else
sql = sql + " WHERE TA.geokey = TB.geokey";
}
else
{
gbtLog(QObject::tr("Cannot insert temporary shapes."));
gbtLog(qry.lastError().databaseText());
}
}
else
{
gbtLog(QObject::tr("Cannot shapes temporary table."));
gbtLog(qry.lastError().databaseText());
}
}
}
gbtLog(QObject::tr("Classifying...Please wait"));
sql = headsql + sql;
if (!qry.exec(sql))
{
gbtLog(QObject::tr("Cannot classify dataset."));
gbtLog(qry.lastError().databaseText());
mydb.close();
con.closeConnection();
return 1;
}
int Hours;
int Minutes;
int Seconds;
int Milliseconds;
Milliseconds = procTime.elapsed();
Hours = Milliseconds / (1000*60*60);
Minutes = (Milliseconds % (1000*60*60)) / (1000*60);
Seconds = ((Milliseconds % (1000*60*60)) % (1000*60)) / 1000;
gbtLog("Finished in " + QString::number(Hours) + " Hours," + QString::number(Minutes) + " Minutes and " + QString::number(Seconds) + " Seconds.");
mydb.close();
con.closeConnection();
return 0;
}
return 0;
}
JNIClassBase::~JNIClassBase()
{
getClasses().removeValue (this);
}
void epregisterFunctions()
{
if (doneRegister) return;
doneRegister=true;
epregisterClass(eregexp);
epregisterClassConstructor(eregexp,(const estr&));
epregisterClassConverterCast(eregexp,estr);
epregisterClassMethod(eregexp,compile);
epregisterClassMethod2D(eregexp,match,int,(const estr&,int,int) const,evararray(0x00));
epregisterClassMethod2D(eregexp,match,int,(const estr&,int,int&,int&,int) const,evararray(0x00));
// epregisterClassProperty(eregexp,b);
// epregisterClassProperty(eregexp,e);
epregisterClass(eudpsocket);
// epregisterClassMethodD(eudpsocket,listen,"0.0.0.0");
epregisterClassMethodD(eudpsocket,listen,evararray("0.0.0.0"));
epregisterClassMethod(eudpsocket,setReuseAddress);
epregisterClassMethod(eudpsocket,close);
epregisterClassMethod(eudpsocket,shutdown);
epregisterClassMethod(eudpsocket,recvfrom);
epregisterClassMethod(eudpsocket,sendto);
epregisterClassProperty(eudpsocket,onReceive);
epregisterClass(esocket);
epregisterClassMethod(esocket,connect);
epregisterClassMethod(esocket,close);
epregisterClassMethod(esocket,shutdown);
epregisterClassMethod2(esocket,recv,int,(estr&,int));
epregisterClassMethod2(esocket,send,int,(const estr&));
epregisterClassProperty(esocket,onReceive);
epregisterClass(earray<esocket>);
epregisterClassInheritance(earray<esocket>,ebasearray);
/*
epregisterClass(eserver<esocket>);
epregisterClassConstructor(eserver<esocket>,());
epregisterClassMethodD(eserver<esocket>,listen,"0.0.0.0");
epregisterClassMethod2(eserver<esocket>,accept,esocket*,());
epregisterClassProperty(eserver<esocket>,onIncoming);
epregisterClassProperty(eserver<esocket>,sockets);
*/
epregisterClassMethod2(ebasearrayof,addvar,void,(evar&,evar&));
epregisterClassMethod2(ebasearrayof,getvar,evar,(int));
epregisterClassMethod2(ebasearrayof,getvarkey,evar,(int));
epregisterClassMethod2A(ebasearrayof,addvar,"add",void,(evar&,evar&));
epregisterClassMethod2A(ebasearrayof,getvarByKey,"[]",evar,(const evar&));
epregisterClassMethod2A(ebasearrayof,getvar,"values",evar,(int));
epregisterClassMethod2A(ebasearrayof,getvarkey,"keys",evar,(int));
epregisterClassMethod2(ebasearrayof,size,int,());
epregister2(getClasses(),"classes");
epregisterClassProperty(eclassBase,properties);
epregisterClassProperty(eclassBase,methods);
epregisterClassProperty(eclassBase,parents);
epregisterClassConstructor(estrarray,(const estr&));
epregisterClassMethod2(estrarray,add,estr&,(const estr&));
epregisterClassMethod2(estrarray,add,estr&,(const estr&,const estr&));
epregisterClassMethod(estrarray,load);
epregisterClassMethod(estrarray,save);
epregisterClassMethod(estrarray,join);
epregisterClassMethodD(estrarray,find,evararray(0,estrarray::equal));
epregisterClassMethodD(estrarray,ifind,evararray(0));
epregisterClassMethodD(estrarray,refind,evararray(0));
epregisterClassMethodD(estrarray,findkey,evararray(0));
epregisterClassMethodD(estrarray,ifindkey,evararray(0));
epregisterClassMethodD(estrarray,refindkey,evararray(0));
epregisterClassMethod(estrarray,ifindall);
epregisterClassMethod(estrarray,ifindallkey);
epregisterClassMethod(estrarray,refindall);
epregisterClassMethod(estrarray,refindallkey);
epregisterClassMethod2(estrarray,keys,const estr&,(size_t) const);
epregisterClassMethod2(estrarray,values,estr&,(size_t));
epregisterClassMethod4(estrarray,operator[],estr&,(size_t),"[]");
epregisterClassMethod4(estrarray,operator[],estr&,(const estr&),"[]");
epregisterClassMethod4(estrarray,operator[],estrarray,(const eintarray&) const,"[]");
epregisterClassMethod4(estrarray,operator-=,estrarray&,(const estrarray&),"-=");
epregisterClassMethod4(estrarray,operator-,estrarray,(const estrarray&),"-");
epregisterClassMethod3<estrarray>((estr& (estrarray::*)(const estr&)) &estrarray::add,"+=");
epregisterClassMethod2(ebasearray,addvar,void,(evar&));
epregisterClassMethod2(ebasearray,getvar,evar,(size_t));
epregisterClassMethod2(ebasearray,size,size_t,());
epregisterClassMethod2A(ebasearray,addvar,"add",void,(evar&));
epregisterClassMethod2A(ebasearray,getvar,"[]",evar,(size_t));
epregisterClass(etimer);
epregisterClassMethod(etimer,lap);
epregisterClassMethod(etimer,check);
epregisterClassMethod(etimer,reset);
epregisterClassMethod2(evararray,add,evar&,(const evar&));
epregisterClassMethod4(evararray,operator[],evar&,(size_t),"[]");
epregisterClass(efile);
epregisterClassCout(efile);
epregisterClassConstructor(efile,(const estr&));
epregisterClassConstructor(efile,(const estr&,const estr&));
epregisterClassMethod2(efile,open,bool,() const);
epregisterClassMethod2(efile,open,bool,(const estr&,const estr&));
epregisterClassMethod(efile,fileno);
epregisterClassMethod2D(efile,read,int,(estr&,long int) const,evararray(-1l));
epregisterClassMethod2(efile,read,evar,() const);
epregisterClassMethod(efile,readln);
epregisterClassMethod2(efile,write,int,(const estr&) const);
epregisterClassMethod2(efile,write,int,(const evar&) const);
epregisterClassProperty(efile,name);
epregisterClassMethod(efile,size);
epregisterClassMethod(efile,exists);
epregisterClassMethod(efile,basename);
epregisterClassMethod(efile,close);
epregisterClass(edir);
epregisterClassCout(edir);
epregisterClassConstructor(edir,(const estr&));
epregisterClassProperty(edir,dirs);
epregisterClassProperty(edir,files);
epregisterClass(estrarrayof<efile>);
epregisterClassInheritance(estrarrayof<efile>,ebasearrayof);
epregisterClassMethod(estrarrayof<efile>,size);
epregisterClassMethod4(estrarrayof<efile>,operator[],efile&,(const estr&),"[]");
epregisterClassMethod4(estrarrayof<efile>,operator[],efile&,(size_t),"[]");
epregisterClass(estrarrayof<edir>);
epregisterClassInheritance(estrarrayof<edir>,ebasearrayof);
epregisterClassMethod(estrarrayof<edir>,size);
epregisterClassMethod2(estrarrayof<edir>,keys,estr&,(size_t));
epregisterClassMethod2(estrarrayof<edir>,values,edir&,(size_t));
epregisterClassMethod4(estrarrayof<edir>,operator[],edir&,(const estr&),"[]");
epregisterClassMethod4(estrarrayof<edir>,operator[],edir&,(size_t),"[]");
epregisterFuncD(ls,evararray("."));
epregisterFuncD(cd,evararray("~"));
epregisterFunc(pwd);
epregisterFunc2(env,estrarray,());
epregisterClassMethod(ernd,uniform);
#ifdef EUTILS_HAVE_LIBGSL
epregisterClassMethod(ernd,gamma);
epregisterClassMethod(ernd,gaussian);
epregisterClassMethod(ernd,exponential);
epregisterClassMethod(ernd,geometric);
#endif
epregisterFunc2(grep,estr,(estr&,const eregexp&,int));
epregisterFunc3(getParser(),epinterpret,"eval");
epregisterFunc3(getParser(),varexec,"exec");
epregisterFunc3(getParser(),varprint,"print");
epregisterFunc3(getParser(),vartype,"type");
epregisterFunc3(getParser(),varaddress,"addr");
epregisterFunc2(serial,void,(const evar&,estr&));
epregisterFunc2(unserial,evar,(const estr&));
epregister(rnd);
epregister2(getSystem(),"sys");
epregisterClassMethodI(esystem,getTotalRam,"return total amount of RAM in system");
epregisterClassMethodI(esystem,getFreeRam,"return free amount RAM in system");
epregisterClassMethodI(esystem,getBufferRam,"return amount of RAM used by buffers");
epregisterClassMethodI(esystem,getMemLimit,"return maximum memory limit set for process");
}
