GDBMS_for_documentation/transaction_mode_commands_find.cpp

Go to the documentation of this file.

#include "maininclude.h"
#include "listi.h"
#include "settings.h"
#include "hash_table.h"
#include "tr_twin_ht.h"
#include "file_semaphore.h"
#include "some_functions.h"
#include "initial_mode_commands.h"
#include "session_mode_commands.h"
#include "transaction_mode_commands.h"
#include "transaction_mode_commands_types.h"
#include "transaction_mode_commands_nodes.h"
#include "transaction_mode_commands_edges.h"
#include "transaction_mode_commands_find.h"
using namespace std;
int transaction_mode_commands_find::FindAllFriends(int transaction_USCOREid, string node_USCOREname, string paths_USCOREnodes, int paths_USCOREcount, ns1__FindAllFriendsResponse& _param_27)
{
    char *grphidstr=0;
  char *tridstr=0;
  tridstr=inttostr(transaction_USCOREid);
  grphidstr=settings::getGraphfromTransaction(tridstr);
  if(grphidstr&&tridstr){
    string trfolder;
  
    trfolder+="admin/";
    trfolder+=grphidstr;
    trfolder+="/";
    trfolder+=tridstr;
    string cmd;
    
  
    string edgfolder;
    edgfolder+=trfolder;
    edgfolder+="/edges";
  
    string nodefolder;
    nodefolder=trfolder;
    nodefolder+="/nodes";
  
  
    string grfolder;
    grfolder+="admin/";
    grfolder+=grphidstr;
    
    
    string realedges_folder;
    realedges_folder+=grfolder;
    realedges_folder+="/edges";
  
    string realnodes_folder;
    realnodes_folder+=grfolder;
    realnodes_folder+="/nodes";
    
    hash_table trn("transactions", "admin/transactions", "id;user_id;graph_id;time_started", "id;user_id;graph_id", "id");
    
    
    hash_table real_edges("edges", realedges_folder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id");
    hash_table real_nodes("nodes", realnodes_folder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id");
  
    tr_twin_ht edgtwin("edges", edgfolder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id", transaction_USCOREid, edgfolder.c_str(), &real_edges);
    tr_twin_ht nodtwin("nodes", nodefolder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id", transaction_USCOREid, nodefolder.c_str(), &real_nodes);
    
    char *idnode=nodtwin.FindRecord("name", node_USCOREname.c_str(), "id");
    if(idnode){
     _param_27.Xiksml_USCOREresponse+="<friends id=\""; 
     _param_27.Xiksml_USCOREresponse+=idnode;
     _param_27.Xiksml_USCOREresponse+="\">";
     listi res(0, ',');
     listi metr(0, ',');
     string path_edg;
     path_edg="id";
     transaction_mode_commands_find::getNeighborNodes(strtoint(idnode), res, metr, nodtwin, edgtwin, path_edg);
     int i, j;
     int ni=res.getnum();
     for(i=0; i<ni; i++){
       _param_27.Xiksml_USCOREresponse+="<neighbor id=\"";
       _param_27.Xiksml_USCOREresponse+=res.getith(i);
       _param_27.Xiksml_USCOREresponse+="\">";
       listi paths_l(paths_USCOREnodes.c_str(), ";");
       int nj=paths_l.getnum();
       for(j=0; j<nj; j++){
         char *curpath=paths_l.getith(j);
         
         if(curpath){
          if(settings::is_type_path_valid(curpath, grphidstr)){
            char *val=nodtwin.FindRecord("id", res.getith(i), "data");
            if(val){
             XMLNode x1=XMLNode::parseString(val);
             XMLNode x2=x1.getChildNodeByPath(curpath, 0, '.');
             _param_27.Xiksml_USCOREresponse+="<val name=\"";
             _param_27.Xiksml_USCOREresponse+=x2.getName();
             _param_27.Xiksml_USCOREresponse+="\">";
             _param_27.Xiksml_USCOREresponse+=x2.getText();
             
             _param_27.Xiksml_USCOREresponse+="</val>";
              
             delete val; 
            }
            
            
          }else{
            _param_27.Xiksml_USCOREresponse+="<error>";
            _param_27.Xiksml_USCOREresponse+="Invalid path.";
            _param_27.Xiksml_USCOREresponse+="</error>";
            
            
          }
           
           
           
          delete curpath; 
         }
         
         
         
       }      
       
       _param_27.Xiksml_USCOREresponse+="</neighbor>";
       
       
     }
     _param_27.Xiksml_USCOREresponse+="</friends>";
     delete idnode; 
    }
    
    }else{
     _param_27.Xiksml_USCOREresponse+="<error>";
     _param_27.Xiksml_USCOREresponse+="Node name not found.";
     _param_27.Xiksml_USCOREresponse+="</error>";
    }
  
  return 0;
}
int transaction_mode_commands_find::FindAllPathsBetweenNodes(int transaction_USCOREid, string node_USCOREname1, string node_USCOREname2, string paths, int paths_USCOREcount, string path_USCOREedges, ns1__FindAllPathsBetweenNodesResponse& _param_26)
{
    char *grphidstr=0;
  char *tridstr=0;
  tridstr=inttostr(transaction_USCOREid);
  grphidstr=settings::getGraphfromTransaction(tridstr);
  if(grphidstr&&tridstr){
    string trfolder;
  
    trfolder+="admin/";
    trfolder+=grphidstr;
    trfolder+="/";
    trfolder+=tridstr;
    string cmd;
    
  
    string edgfolder;
    edgfolder+=trfolder;
    edgfolder+="/edges";
  
    string nodefolder;
    nodefolder=trfolder;
    nodefolder+="/nodes";
  
  
    string grfolder;
    grfolder+="admin/";
    grfolder+=grphidstr;
    
    
    string realedges_folder;
    realedges_folder+=grfolder;
    realedges_folder+="/edges";
  
    string realnodes_folder;
    realnodes_folder+=grfolder;
    realnodes_folder+="/nodes";
    
    hash_table trn("transactions", "admin/transactions", "id;user_id;graph_id;time_started", "id;user_id;graph_id", "id");
    
    
    hash_table real_edges("edges", realedges_folder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id");
    hash_table real_nodes("nodes", realnodes_folder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id");
  
    tr_twin_ht edgtwin("edges", edgfolder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id", transaction_USCOREid, edgfolder.c_str(), &real_edges);
    tr_twin_ht nodtwin("nodes", nodefolder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id", transaction_USCOREid, nodefolder.c_str(), &real_nodes);
    char *idnod1=nodtwin.FindRecord("name", node_USCOREname1.c_str(), "id");
    if(idnod1){
      char *idnod2=nodtwin.FindRecord("name", node_USCOREname2.c_str(), "id");
      if(idnod2){
        int i;
        listi paths_l(paths.c_str(), ";");
        
        for(i=0; i<paths_USCOREcount; i++){
          if(!settings::is_type_path_valid(paths_l.getith(i), grphidstr)){
            break;
          }
          
        }
        if(i>=paths_USCOREcount){
          if(settings::is_type_path_valid(path_USCOREedges.c_str(), grphidstr)){
            //vhodnite danni sa validni
            char *used=new char[MAXNUM];
            unsigned *path=new unsigned[MAXNUM];
            if(used&&path){
              _param_26.Xiksml_USCOREresponse+="<paths>";
              unsigned count=0;
              int k;
              for(k=0; k<MAXNUM; k++){
                used[k]=0;
              }
            
              transaction_mode_commands_find::allDFS(strtoint(idnod1), strtoint(idnod2), used, path, count, nodtwin, edgtwin, _param_26.Xiksml_USCOREresponse, path_USCOREedges, paths);
            
              _param_26.Xiksml_USCOREresponse+="</paths>";
              delete used;
              delete path;
            
            }else{
              
              _param_26.Xiksml_USCOREresponse+="<error>";
              _param_26.Xiksml_USCOREresponse+="Memory allocation error.";
              _param_26.Xiksml_USCOREresponse+="</error>";
            }
            
          }else{
            
            _param_26.Xiksml_USCOREresponse+="<error>";
            _param_26.Xiksml_USCOREresponse+="Type paths error.";
            _param_26.Xiksml_USCOREresponse+="</error>";
            
          }
          
          
          
          
        }else{
          _param_26.Xiksml_USCOREresponse+="<error>";
          _param_26.Xiksml_USCOREresponse+="Type paths error.";
          _param_26.Xiksml_USCOREresponse+="</error>";
        }
        delete idnod2;
      }else{
        _param_26.Xiksml_USCOREresponse+="<error>";
        _param_26.Xiksml_USCOREresponse+="Node name not found.";
        _param_26.Xiksml_USCOREresponse+="</error>";
      }
      delete idnod1;
    }else{
     _param_26.Xiksml_USCOREresponse+="<error>";
     _param_26.Xiksml_USCOREresponse+="Node name not found.";
     _param_26.Xiksml_USCOREresponse+="</error>";
    }
  }
  return 0;
}

void transaction_mode_commands_find::allDFS(unsigned int i, unsigned int j, char* used, unsigned int* path, unsigned int& count, tr_twin_ht& nodtwin1, tr_twin_ht& edgtwin1, string& XMLRes, string& path_edges, string& paths)
{
  unsigned k;
  if(i==j){
    path[count]=j;
    transaction_mode_commands_find::getAllDFS_XML_Path(path, count, XMLRes, nodtwin1, edgtwin1, paths);
    return;
  }
  /*markirane na poseteniq vryh*/
  used[i]=1;
  path[count++]=i;
  listi neighb(0, ',');
  listi metrics_edges(0, ',');
  transaction_mode_commands_find::getNeighborNodes(i, neighb, metrics_edges, nodtwin1, edgtwin1, path_edges);
  int ni=neighb.getnum();
  for(k=0; k<ni; k++){
    char *neighbindstr=neighb.getith(k);
    if(neighbindstr){
     int ki=strtoint(neighbindstr);
     if(!used[ki])
       allDFS(ki, j, used, path, count, nodtwin1, edgtwin1, XMLRes, path_edges, paths);
     used[i]=0;
     count--;

      
     delete neighbindstr; 
    }
  }
  
}
void transaction_mode_commands_find::getAllDFS_XML_Path(unsigned int* path, unsigned int& count, string& XMLRes, tr_twin_ht& nodtwin1, tr_twin_ht& edgtwin1, string& paths)
{
  unsigned k;
  XMLRes+="<path>";
  for(k=0; k<=count; k++){
    char *idknode=inttostr(k);
    if(idknode){
      char *dataknode=nodtwin1.FindRecord("id", idknode, "data");
      XMLRes+="<node id=\"";
      XMLRes+=idknode;
      XMLRes+="\">";
      
      if(dataknode){
        XMLNode x1, x2;
        listi paths_l(paths.c_str(), ';');
        int j, nj=paths_l.getnum();
        for(j=0; j<nj; j++){
          char *curpath=paths_l.getith(j);
          if(curpath){
            x1=XMLNode::parseString(dataknode);
            x2=x1.getChildNodeByPath(curpath, 0, '.');
            char *cname=x2.getName();
            char *cval=x2.getText();
            if(cname&&cval){
             XMLRes+="<val name=\""; 
             XMLRes+=cname;
             XMLRes+="\">";
             XMLRes+=cval;
             XMLRes+="</val>";
              
             delete cname;
             delete cval;
            }
            
            delete curpath;
          }
          
        }
        
        
        delete dataknode;
      }
      XMLRes+="</node>";
      
      delete idknode;
    }
    
  }
  
  XMLRes+="</path>";
}

int transaction_mode_commands_find::FindBFS(int transaction_USCOREid, string node_USCOREname, string paths_USCOREnodes, string paths_USCOREvalues, int paths_USCOREcount, int limit_USCOREnodes, ns1__FindBFSResponse& _param_28)
{
   char *grphidstr=0;
  char *tridstr=0;
  tridstr=inttostr(transaction_USCOREid);
  grphidstr=settings::getGraphfromTransaction(tridstr);
  if(grphidstr&&tridstr){
    string trfolder;
  
    trfolder+="admin/";
    trfolder+=grphidstr;
    trfolder+="/";
    trfolder+=tridstr;
    string cmd;
    
  
    string edgfolder;
    edgfolder+=trfolder;
    edgfolder+="/edges";
  
    string nodefolder;
    nodefolder=trfolder;
    nodefolder+="/nodes";
  
  
    string grfolder;
    grfolder+="admin/";
    grfolder+=grphidstr;
    
    
    string realedges_folder;
    realedges_folder+=grfolder;
    realedges_folder+="/edges";
  
    string realnodes_folder;
    realnodes_folder+=grfolder;
    realnodes_folder+="/nodes";
    
    hash_table trn("transactions", "admin/transactions", "id;user_id;graph_id;time_started", "id;user_id;graph_id", "id");
    
    
    hash_table real_edges("edges", realedges_folder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id");
    hash_table real_nodes("nodes", realnodes_folder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id");
  
    tr_twin_ht edgtwin("edges", edgfolder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id", transaction_USCOREid, edgfolder.c_str(), &real_edges);
    tr_twin_ht nodtwin("nodes", nodefolder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id", transaction_USCOREid, nodefolder.c_str(), &real_nodes);
    
    char *idnode=nodtwin.FindRecord("name", node_USCOREname.c_str(), "id");
    if(idnode){
     int idnode_int=strtoint(idnode);
     listi paths_nodes_l(paths_USCOREnodes.c_str(), ';');
     listi paths_values_l(paths_USCOREvalues.c_str(), ';');
     int k;
     char *used= new char[MAXNUM];
     unsigned *queue = new unsigned[MAXNUM];
     for(k=0; k<MAXNUM; k++){
       used[k]=0;
       queue[k]=0;
     }
     unsigned j, p, currentVert=0, levelVertex=1, queueEnd=1;
     queue[0]=idnode_int;
     used[idnode_int]=1;
     _param_28.Xiksml_USCOREresponse+="<nodes>";
     while(currentVert<queueEnd){
       for(p=currentVert; p<levelVertex; p++){
         /*vzemame poredniq element ot opa6kata*/
         printDFS( queue[p], used, paths_nodes_l, paths_values_l, _param_28.Xiksml_USCOREresponse, nodtwin, edgtwin);
         currentVert++;
         /*dobavyame vseki neobhoden naslednik v opa6kata*/
         listi neighbn(0, ',');
         listi metrneighbn(0, ',');
         transaction_mode_commands_find::getNeighborNodes(queue[p], neighbn, metrneighbn, nodtwin, edgtwin, "id");
         unsigned kn=neighbn.getnum();
         for(k=0; k<kn; k++){
            char *curneinod=neighbn.getith(k);
            if(curneinod){
              int in_curneinode=strtoint(curneinod);
              if(!used[in_curneinode]){
                queue[queueEnd++]=in_curneinode;
                used[in_curneinode]=1;
                
              }
              
              
              delete curneinod;
            }
           
           
         }
         
       }
       levelVertex=queueEnd;
     }
     
     _param_28.Xiksml_USCOREresponse+="</nodes>";
     
     delete idnode; 
    }
    
    }else{
     _param_28.Xiksml_USCOREresponse+="<error>";
     _param_28.Xiksml_USCOREresponse+="Node name not found.";
     _param_28.Xiksml_USCOREresponse+="</error>";
    }
  
  return 0;
}
int transaction_mode_commands_find::FindDFS(int transaction_USCOREid, string node_USCOREname, string paths_USCOREnodes, string paths_USCOREvalues, int paths_USCOREcount, int limit_USCOREnodes, ns1__FindDFSResponse& _param_29)
{
   char *grphidstr=0;
  char *tridstr=0;
  tridstr=inttostr(transaction_USCOREid);
  grphidstr=settings::getGraphfromTransaction(tridstr);
  if(grphidstr&&tridstr){
    string trfolder;
  
    trfolder+="admin/";
    trfolder+=grphidstr;
    trfolder+="/";
    trfolder+=tridstr;
    string cmd;
    
  
    string edgfolder;
    edgfolder+=trfolder;
    edgfolder+="/edges";
  
    string nodefolder;
    nodefolder=trfolder;
    nodefolder+="/nodes";
  
  
    string grfolder;
    grfolder+="admin/";
    grfolder+=grphidstr;
    
    
    string realedges_folder;
    realedges_folder+=grfolder;
    realedges_folder+="/edges";
  
    string realnodes_folder;
    realnodes_folder+=grfolder;
    realnodes_folder+="/nodes";
    
    hash_table trn("transactions", "admin/transactions", "id;user_id;graph_id;time_started", "id;user_id;graph_id", "id");
    
    
    hash_table real_edges("edges", realedges_folder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id");
    hash_table real_nodes("nodes", realnodes_folder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id");
  
    tr_twin_ht edgtwin("edges", edgfolder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id", transaction_USCOREid, edgfolder.c_str(), &real_edges);
    tr_twin_ht nodtwin("nodes", nodefolder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id", transaction_USCOREid, nodefolder.c_str(), &real_nodes);
    
    char *idnode=nodtwin.FindRecord("name", node_USCOREname.c_str(), "id");
    if(idnode){
     int idnode_int=strtoint(idnode);
     listi paths_nodes_l(paths_USCOREnodes.c_str(), ';');
     listi paths_values_l(paths_USCOREvalues.c_str(), ';');
     int k;
     char *used= new char[MAXNUM];
     
     for(k=0; k<MAXNUM; k++){
       used[k]=0;
       
     }
     _param_29.Xiksml_USCOREresponse+="<nodes>";
     transaction_mode_commands_find::DFS(idnode_int, used, paths_nodes_l, paths_values_l, _param_29.Xiksml_USCOREresponse, nodtwin, edgtwin, limit_USCOREnodes, 0);
     
     _param_29.Xiksml_USCOREresponse+="</nodes>";
     
     delete idnode; 
    }
    
    }else{
     _param_29.Xiksml_USCOREresponse+="<error>";
     _param_29.Xiksml_USCOREresponse+="Node name not found.";
     _param_29.Xiksml_USCOREresponse+="</error>";
    }
  
  return 0;
}
void transaction_mode_commands_find::DFS(unsigned int i, char* used, listi& paths_nodes_l, listi& paths_values_l, std::string& response, tr_twin_ht& nodtwin1, tr_twin_ht& edgtwin1, int limit_nodes, int countvar)
{
  if(countvar>=limit_nodes)
    return;
  unsigned k;
  used[i]=1;
  printDFS( i, used, paths_nodes_l, paths_values_l, response, nodtwin1, edgtwin1);
  listi neighbn(0, ',');
  listi metrneighbn(0, ',');
  transaction_mode_commands_find::getNeighborNodes(i, neighbn, metrneighbn, nodtwin1, edgtwin1, "id");
  unsigned kn=neighbn.getnum();
  for(k=0; k<kn; k++){
    char *curneinod=neighbn.getith(k);
    if(curneinod){
     if(!used[strtoint(curneinod)]){
       DFS( strtoint(curneinod), used, paths_nodes_l, paths_values_l, response, nodtwin1, edgtwin1, limit_nodes, countvar+1);
     }
     delete curneinod; 
    }
    
    
  }
}
void transaction_mode_commands_find::printDFS(unsigned int i, char* used, listi& paths_nodes_l, listi& paths_values_l, string& response, tr_twin_ht& nodtwin1, tr_twin_ht& edgtwin1)
{
  
  char *nodeidstr=inttostr(i);
  if(nodeidstr){
    response+="<node id=\"";
    response+=nodeidstr;
    response+="\">";
    int k;
    int kn=paths_nodes_l.getnum();
    for(k=0; k<kn; k++){
      char *data=nodtwin1.FindRecord("id", nodeidstr, "data");
      if(data){
        XMLNode x1, x2;
        x1=XMLNode::parseString(data);
        char *curpath=paths_nodes_l.getith(k);
        if(curpath){
         x2=x1.getChildNodeByPath(curpath, 0, '.'); 
         response+="<val name=\"";
         response+=x2.getName();
         response+="\">";
         response+=x2.getText();
         response+="</val>";
         delete curpath; 
        }
        
        delete data;
      }
      
      
    }
    
    
    response+="</node>";
    
    delete nodeidstr;
  }
}

int transaction_mode_commands_find::FindMaxPathBetweenNodes(int transaction_USCOREid, string node_USCOREname1, string node_USCOREname2, string paths, int paths_USCOREcount, string path_USCOREedges, ns1__FindMaxPathBetweenNodesResponse& _param_25)
{
    char *grphidstr=0;
  char *tridstr=0;
  tridstr=inttostr(transaction_USCOREid);
  grphidstr=settings::getGraphfromTransaction(tridstr);
  if(grphidstr&&tridstr){
    string trfolder;
  
    trfolder+="admin/";
    trfolder+=grphidstr;
    trfolder+="/";
    trfolder+=tridstr;
    string cmd;
    
  
    string edgfolder;
    edgfolder+=trfolder;
    edgfolder+="/edges";
  
    string nodefolder;
    nodefolder=trfolder;
    nodefolder+="/nodes";
  
  
    string grfolder;
    grfolder+="admin/";
    grfolder+=grphidstr;
    
    
    string realedges_folder;
    realedges_folder+=grfolder;
    realedges_folder+="/edges";
  
    string realnodes_folder;
    realnodes_folder+=grfolder;
    realnodes_folder+="/nodes";
    
    hash_table trn("transactions", "admin/transactions", "id;user_id;graph_id;time_started", "id;user_id;graph_id", "id");
    
    
    hash_table real_edges("edges", realedges_folder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id");
    hash_table real_nodes("nodes", realnodes_folder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id");
  
    tr_twin_ht edgtwin("edges", edgfolder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id", transaction_USCOREid, edgfolder.c_str(), &real_edges);
    tr_twin_ht nodtwin("nodes", nodefolder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id", transaction_USCOREid, nodefolder.c_str(), &real_nodes);
    char *idnod1=nodtwin.FindRecord("name", node_USCOREname1.c_str(), "id");
    if(idnod1){
      char *idnod2=nodtwin.FindRecord("name", node_USCOREname2.c_str(), "id");
      if(idnod2){
        int i;
        listi paths_l(paths.c_str(), ";");
        
        for(i=0; i<paths_USCOREcount; i++){
          if(!settings::is_type_path_valid(paths_l.getith(i), grphidstr)){
            break;
          }
          
        }
        if(i>=paths_USCOREcount){
          if(settings::is_type_path_valid(path_USCOREedges.c_str(), grphidstr)){
            //vhodnite danni sa validni
            char *T=new char[MAXNUM];
            unsigned *d= new unsigned[MAXNUM];
            int *pred=new int[MAXNUM];
            if(T&&d&&pred){
              int s=strtoint(idnod1);
              transaction_mode_commands_find::dijkstraMax(s, T, d, pred, path_USCOREedges, nodtwin, edgtwin);
              transaction_mode_commands_find::dijkstraGetXMLResult(s, _param_25.Xiksml_USCOREresponse, paths, path_USCOREedges, T, d, pred, strtoint(idnod2), nodtwin);
              delete T;
              delete d;
              delete pred;
            }else{
              _param_25.Xiksml_USCOREresponse+="<error>";
              _param_25.Xiksml_USCOREresponse+="Memory allocation error.";
              _param_25.Xiksml_USCOREresponse+="</error>";
            }
            
            
            
          }else{
            _param_25.Xiksml_USCOREresponse+="<error>";
            _param_25.Xiksml_USCOREresponse+="Type paths error.";
            _param_25.Xiksml_USCOREresponse+="</error>";
            
          }
          
          
          
          
        }else{
          _param_25.Xiksml_USCOREresponse+="<error>";
          _param_25.Xiksml_USCOREresponse+="Type paths error.";
          _param_25.Xiksml_USCOREresponse+="</error>";
        }
        delete idnod2;
      }else{
        _param_25.Xiksml_USCOREresponse+="<error>";
        _param_25.Xiksml_USCOREresponse+="Node name not found.";
        _param_25.Xiksml_USCOREresponse+="</error>";
      }
      delete idnod1;
    }else{
     _param_25.Xiksml_USCOREresponse+="<error>";
     _param_25.Xiksml_USCOREresponse+="Node name not found.";
     _param_25.Xiksml_USCOREresponse+="</error>";
    }
  }
  return 0;
}
int transaction_mode_commands_find::FindMinPathBetweenNodes(int transaction_USCOREid, string node_USCOREname1, string node_USCOREname2, string paths, int paths_USCOREcount, string path_USCOREedges, ns1__FindMinPathBetweenNodesResponse& _param_24)
{
    char *grphidstr=0;
  char *tridstr=0;
  tridstr=inttostr(transaction_USCOREid);
  grphidstr=settings::getGraphfromTransaction(tridstr);
  if(grphidstr&&tridstr){
    string trfolder;
  
    trfolder+="admin/";
    trfolder+=grphidstr;
    trfolder+="/";
    trfolder+=tridstr;
    string cmd;
    
  
    string edgfolder;
    edgfolder+=trfolder;
    edgfolder+="/edges";
  
    string nodefolder;
    nodefolder=trfolder;
    nodefolder+="/nodes";
  
  
    string grfolder;
    grfolder+="admin/";
    grfolder+=grphidstr;
    
    
    string realedges_folder;
    realedges_folder+=grfolder;
    realedges_folder+="/edges";
  
    string realnodes_folder;
    realnodes_folder+=grfolder;
    realnodes_folder+="/nodes";
    
    hash_table trn("transactions", "admin/transactions", "id;user_id;graph_id;time_started", "id;user_id;graph_id", "id");
    
    
    hash_table real_edges("edges", realedges_folder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id");
    hash_table real_nodes("nodes", realnodes_folder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id");
  
    tr_twin_ht edgtwin("edges", edgfolder.c_str(), "id;name;data;inodes;onodes;type_id;tr_id", "id;name;inodes;onodes;type_id;tr_id", "id", transaction_USCOREid, edgfolder.c_str(), &real_edges);
    tr_twin_ht nodtwin("nodes", nodefolder.c_str(), "id;name;data;iedges;oedges;type_id;tr_id", "id;name;iedges;oedges;type_id;tr_id", "id", transaction_USCOREid, nodefolder.c_str(), &real_nodes);
    char *idnod1=nodtwin.FindRecord("name", node_USCOREname1.c_str(), "id");
    if(idnod1){
      char *idnod2=nodtwin.FindRecord("name", node_USCOREname2.c_str(), "id");
      if(idnod2){
        int i;
        listi paths_l(paths.c_str(), ";");
        
        for(i=0; i<paths_USCOREcount; i++){
          if(!settings::is_type_path_valid(paths_l.getith(i), grphidstr)){
            break;
          }
          
        }
        if(i>=paths_USCOREcount){
          if(settings::is_type_path_valid(path_USCOREedges.c_str(), grphidstr)){
            //vhodnite danni sa validni
            char *T=new char[MAXNUM];
            unsigned *d= new unsigned[MAXNUM];
            int *pred=new int[MAXNUM];
            if(T&&d&&pred){
              int s=strtoint(idnod1);
              transaction_mode_commands_find::dijkstraMin(s, T, d, pred, path_USCOREedges, nodtwin, edgtwin);
              transaction_mode_commands_find::dijkstraGetXMLResult(s, _param_24.Xiksml_USCOREresponse, paths, path_USCOREedges, T, d, pred, strtoint(idnod2), nodtwin);
              delete T;
              delete d;
              delete pred;
            }else{
              _param_24.Xiksml_USCOREresponse+="<error>";
              _param_24.Xiksml_USCOREresponse+="Memory allocation error.";
              _param_24.Xiksml_USCOREresponse+="</error>";
            }
            
            
            
          }else{
            _param_24.Xiksml_USCOREresponse+="<error>";
            _param_24.Xiksml_USCOREresponse+="Type paths error.";
            _param_24.Xiksml_USCOREresponse+="</error>";
            
          }
          
          
          
          
        }else{
          _param_24.Xiksml_USCOREresponse+="<error>";
          _param_24.Xiksml_USCOREresponse+="Type paths error.";
          _param_24.Xiksml_USCOREresponse+="</error>";
        }
        delete idnod2;
      }else{
        _param_24.Xiksml_USCOREresponse+="<error>";
        _param_24.Xiksml_USCOREresponse+="Node name not found.";
        _param_24.Xiksml_USCOREresponse+="</error>";
      }
      delete idnod1;
    }else{
     _param_24.Xiksml_USCOREresponse+="<error>";
     _param_24.Xiksml_USCOREresponse+="Node name not found.";
     _param_24.Xiksml_USCOREresponse+="</error>";
    }
  }
  return 0;
}
void transaction_mode_commands_find::dijkstraGetXMLResult(int s, string& result, string& paths, string& path_edges, char* T, unsigned int* d, int* pred, int endnodeid, tr_twin_ht& nodtwin1)
{
  result+="<nodes metric=\"";
  result+=path_edges;
  result+="\">";
  listi paths_l(paths.c_str(), ';');
  int num_paths_l=paths_l.getnum();
  int i=0, j=0, k=0, currec=endnodeid;
  while(currec!=s){
    char *currecstr=inttostr(currec);
    if(currecstr){
      
      char *datafield=nodtwin1.FindRecord("id", currecstr, "data");
      result+="<node id=\"";
      result+=currecstr;
      result+="\">";
      if(datafield){
        
        
        
        for(i=0; i<num_paths_l; i++){
          char *curpath=paths_l.getith(i);
          if(curpath){
            XMLNode x1=XMLNode::parseString(datafield);
            XMLNode x2;
            x2=x1.getChildNodeByPath(curpath, 0, '.');
            result+="<val name=\"";
            result+=x2.getName();
            result+="\">";
            result+=x2.getText();
            result+="</val>";
            delete curpath;
          }
          
        }
        
        
        
        
        
        delete datafield;
      }
      
      
      result+="</node>";
      delete currecstr;
      currec=pred[currec];
    }
    
  }
  
  result+="</nodes>";
  
}


void transaction_mode_commands_find::dijkstraMin(int s, char* T, unsigned int* d, int* pred, string& path_edges, tr_twin_ht& nodtwin1, tr_twin_ht& edgtwin1)
{
  int i;
  //inizializacii
  for(i=0; i<MAXNUM; i++){
    T[i]=1;
    pred[i]=0;
    d[i]=NO_PARENT;
  }
  T[s]=0;
  listi neighb_s(0, ',');
  listi metrics_edges(0, ',');
  transaction_mode_commands_find::getNeighborNodes(s, neighb_s, metrics_edges, nodtwin1, edgtwin1, path_edges);
  int len_neighb_s=neighb_s.getnum();
  //inizializirane na d i pred
  for(i=0; i<len_neighb_s; i++){
    char *str1=neighb_s.getith(i);
    char *str2=metrics_edges.getith(i);
    if(str1&&str2){
      d[strtoint(str1)]=strtoint(str2);
      pred[strtoint(str1)]=s;
      delete str1; 
      delete str2;
    }
    
  }
  pred[s]=NO_PARENT;
  while(1){
    //izbirane na j ot T, za kojto d[j] e minimalno
    unsigned j=NO_PARENT;
    unsigned di= NO_PARENT;
    for(i=0; i<MAXNUM; i++){
      if(T[i]&&d[i]<di){
        di=d[i];
        j=i;
      }
    }
    //ako d[i]=maksimalnata stojnost za vsi4ki vyzli: izhod
    if(j==NO_PARENT)
      break;
    //izklu4vame j ot T
    T[j]=0;
    /*za vsqko i ot T izpylnqvame D[i]=min(d[i], d[j]+metricata na rebroto mejdu j i i)*/
    listi neighb_j(0, ',');
    listi metrics_edgesj(0, ',');
    transaction_mode_commands_find::getNeighborNodes(j, neighb_j, metrics_edgesj, nodtwin1, edgtwin1, path_edges);
    for(i=0; i<neighb_j.getnum(); i++){
      char *strindi=neighb_j.getith(i);
      char *metrindi=metrics_edgesj.getith(i);
      if(strindi&&metrindi){
        int ii=strtoint(strindi);
        if(T[ii]){
          if(d[ii]>d[j]+strtoint(metrindi)){
            d[ii]=d[j]+strtoint(metrindi);
            pred[ii]=j;
            
          }
        
        }
        delete strindi;
        delete metrindi;
      }
      
      
    }
    
    
  }
  
  
  
}
void transaction_mode_commands_find::getNeighborNodes(int node_id, listi& result, listi& metrics_edges, tr_twin_ht& nodtwin1, tr_twin_ht& edgtwin1, string& path_edges_1)
{
  char *nodeidstr=inttostr(node_id);
  if(nodeidstr){
    int stacki=0;
    char *oedges_str=nodtwin1.FindRecord("id", nodeidstr, "oedges");
    if(oedges_str){
      listi oedges(oedges_str, ',');
      int i, ni=oedges.getnum();
      for(i=0; i<ni; i++){
        char *data_edges=edgtwin1.FindRecord("id", oedges.getith(i), "data");
        if(data_edges){
          XMLNode x1, x2;
          x1=XMLNode::parseString(data_edges);
          x2=x1.getChildNodeByPath(path_edges_1.c_str(), 0, '.');
          char *ithedgeid=oedges.getith(i);
          char *metric_ith_edge=x2.getText();
          if(ithedgeid&&metric_ith_edge){
            int j=0;
            char *onodesliststr=edgtwin1.FindRecord("id", ithedgeid, "onodes");
            if(onodesliststr){
              listi onodeslist(onodesliststr, ',');
              int nj=onodeslist.getnum();
              for(j=0; j<nj; j++){
                metrics_edges.addelement(metric_ith_edge);
                
                result.addelement(onodeslist.getith(i));
                
              }
              
              delete onodesliststr;
            }
            
            
            delete ithedgeid;
            delete metric_ith_edge;
          }
          
          delete data_edges; 
        }
        
      }
      
      delete oedges_str;
    }
    
    delete nodeidstr;
  }
}
void transaction_mode_commands_find::dijkstraMax(int s, char* T, unsigned int* d, int* pred, string& path_edges, tr_twin_ht& nodtwin1, tr_twin_ht& edgtwin1)
{
  int i;
  //inizializacii
  for(i=0; i<MAXNUM; i++){
    T[i]=1;
    pred[i]=0;
    d[i]=0;
  }
  T[s]=0;
  listi neighb_s(0, ',');
  listi metrics_edges(0, ',');
  transaction_mode_commands_find::getNeighborNodes(s, neighb_s, metrics_edges, nodtwin1, edgtwin1, path_edges);
  int len_neighb_s=neighb_s.getnum();
  //inizializirane na d i pred
  for(i=0; i<len_neighb_s; i++){
    char *str1=neighb_s.getith(i);
    char *str2=metrics_edges.getith(i);
    if(str1&&str2){
      d[strtoint(str1)]=strtoint(str2);
      pred[strtoint(str1)]=s;
      delete str1; 
      delete str2;
    }
    
  }
  pred[s]=NO_PARENT;
  while(1){
    //izbirane na j ot T, za kojto d[j] e maximalno
    unsigned j=0;
    unsigned di= 0;
    for(i=0; i<MAXNUM; i++){
      if(T[i]&&d[i]>di){
        di=d[i];
        j=i;
      }
    }
    //ako d[i]=minimalnata stojnost za vsi4ki vyzli: izhod
    if(j==0)
      break;
    //izklu4vame j ot T
    T[j]=0;
    /*za vsqko i ot T izpylnqvame D[i]=min(d[i], d[j]+metricata na rebroto mejdu j i i)*/
    listi neighb_j(0, ',');
    listi metrics_edgesj(0, ',');
    transaction_mode_commands_find::getNeighborNodes(j, neighb_j, metrics_edgesj, nodtwin1, edgtwin1, path_edges);
    for(i=0; i<neighb_j.getnum(); i++){
      char *strindi=neighb_j.getith(i);
      char *metrindi=metrics_edgesj.getith(i);
      if(strindi&&metrindi){
        int ii=strtoint(strindi);
        if(T[ii]){
          if(d[ii]<d[j]+strtoint(metrindi)){
            d[ii]=d[j]+strtoint(metrindi);
            pred[ii]=j;
            
          }
        
        }
        delete strindi;
        delete metrindi;
      }
      
      
    }
    
    
  }
  
  
  
}