Changeset 1027 for trunk

Timestamp:

May 5, 2009, 5:45:31 PM (15 years ago)

Author:

garnier

Message:

en test. Ok

Location:

trunk/source

Files:

• intercoms/include/G4UIcommandTree.hh (modified) (2 diffs)
• intercoms/src/G4UIcommandTree.cc (modified) (2 diffs)
• interfaces/basic/src/G4VUIshell.cc (modified) (3 diffs)
• interfaces/common/include/G4VBasicShell.hh (modified) (1 diff)
• interfaces/common/src/G4VBasicShell.cc (modified) (4 diffs)

trunk/source/intercoms/include/G4UIcommandTree.hh

@@ -57 +57 @@
       G4UIcommand * FindPath(const char* commandPath);
       G4UIcommandTree * FindCommandTree(const char* commandPath);
+  G4String CompleteCommandPath(const G4String commandPath);
+      // Complete most available caracters in common into command path in the command line 
+      // given
+
       void List();
       void ListCurrent();
@@ -65 +69 @@
       G4String CreateFileName(const char* pName);
       G4String ModStr(const char* strS);
+  G4String GetFirstMatchedString(const G4String&,const G4String&) const;
 
       std::vector<G4UIcommand*> command;

trunk/source/intercoms/src/G4UIcommandTree.cc

@@ -199 +199 @@
 G4UIcommandTree * G4UIcommandTree::FindCommandTree(const char* commandPath)
 {
+  printf("G4UIcommandTree::FindCommandTree %s\n",commandPath);
   G4String remainingPath = commandPath;
   if( remainingPath.index( pathName ) == std::string::npos )
@@ -219 +220 @@
       }
     }
+  } else {
+    return this;
   }
   return NULL;
 }
+
+G4String G4UIcommandTree::CompleteCommandPath(const G4String aCommandPath)
+{
+#ifdef G4DEBUG
+  printf("G4UIcommandTree::FindMatchingPath %s\n",aCommandPath.c_str());
+#endif
+  G4String pathName = aCommandPath;
+  G4String remainingPath = aCommandPath;
+
+  // find the tree
+  G4int jpre= pathName.last('/');
+  if(jpre != G4int(G4String::npos)) pathName.remove(jpre+1);
+  G4UIcommandTree* aTree = FindCommandTree(pathName);
+
+  G4String empty = "";
+  if (!aTree) {
+    return empty;
+  }
+  
+  if( pathName.index( pathName ) == std::string::npos ) return empty;
+
+#ifdef G4DEBUG
+  printf("G4UIcommandTree::FindMatchingPath remainingPath:%s\n",remainingPath.c_str());
+#endif
+
+  std::vector<G4String> paths;
+
+  // list matched directories/commands
+  G4String stream, strtmp;
+  G4int nMatch= 0;
+
+  int Ndir= aTree-> GetTreeEntry();
+  int Ncmd= aTree-> GetCommandEntry();
+  
+  // directory ...
+  for(G4int idir=1; idir<=Ndir; idir++) {
+    G4String fpdir= aTree-> GetTree(idir)-> GetPathName();
+#ifdef G4DEBUG
+    printf("G4UIcommandTree::FindMatchingPath command %d/%d %s\n",idir,Ndir,fpdir.c_str());
+#endif
+    // matching test
+    if( fpdir.index(remainingPath, 0) == 0) {
+      if(nMatch==0) {
+#ifdef G4DEBUG
+        printf("G4UIcommandTree::FindMatchingPath directory match0 :%d\n",nMatch);
+#endif
+        stream = fpdir;
+      } else {
+#ifdef G4DEBUG
+        printf("G4UIcommandTree::FindMatchingPath directory match+ :%d\n",nMatch);
+#endif
+        stream = GetFirstMatchedString(fpdir,stream);
+#ifdef G4DEBUG
+        printf("G4UIcommandTree::FindMatchingPath directory match++++ :%s\n",stream.c_str());
+#endif
+      }
+      nMatch++;
+      paths.push_back(fpdir);
+    }
+  }
+  
+  if (paths.size()>=2) {
+    G4cout << "Matching directories :" << G4endl; 
+    for( unsigned int i_thCommand = 0; i_thCommand < paths.size(); i_thCommand++ ) {
+      G4cout << paths[i_thCommand] << G4endl; 
+    }
+  }
+  
+  // command ...
+  std::vector<G4String> commands;
+
+  for(G4int icmd=1; icmd<=Ncmd; icmd++){
+    G4String fpcmd= aTree-> GetPathName() +
+                    aTree-> GetCommand(icmd) -> GetCommandName();
+    // matching test
+    if( fpcmd.index(remainingPath, 0) ==0) {
+      if(nMatch==0) {
+#ifdef G4DEBUG
+        printf("G4UIcommandTree::FindMatchingPath command match0 :%d\n",nMatch);
+#endif
+        stream= fpcmd + " ";
+      } else {
+#ifdef G4DEBUG
+        printf("G4UIcommandTree::FindMatchingPath command match0 :%d\n",nMatch);
+#endif
+        strtmp= fpcmd + " ";
+        stream= GetFirstMatchedString(stream, strtmp);
+      }
+      nMatch++;
+      commands.push_back(fpcmd+" ");
+    }
+  }
+
+  if (commands.size()>=2) {
+    G4cout << "Matching commands :" << G4endl; 
+    for( unsigned int i_thCommand = 0; i_thCommand < commands.size(); i_thCommand++ ) {
+      G4cout << commands[i_thCommand] << G4endl; 
+    }
+  }
+
+
+
+
+//   if( remainingPath == std::string::npos ) {
+// #ifdef G4DEBUG
+//     printf("G4UIcommandTree::FindMatchingPath npos \n");
+// #endif
+//     // Look for number of matching commands :
+//     G4int n_commandEntry = aTree->GetCommandEntry();
+//     for( G4int i_thCommand = 1; i_thCommand <= n_commandEntry; i_thCommand++ ) {
+//       G4UIcommand* cmd = aTree->GetCommand(i_thCommand);
+//       G4String ss = cmd->GetCommandName();
+//       ss.resize(remainingPath.length());
+//       if( remainingPath == ss ) commands.push_back(cmd);
+// #ifdef G4DEBUG
+//       printf("look for command check %s %s \n",ss.c_str(),remainingPath.c_str());
+// #endif
+//     }
+//     n_commandEntry = commands.size();
+// #ifdef G4DEBUG
+//       printf("%d found\n",n_commandEntry);
+// #endif
+//     if(n_commandEntry==1) {
+//       return (pathName + commands[0]->GetCommandName());
+//     } else if (n_commandEntry>=2) {
+//       G4cout << "Matching commands :" << G4endl; 
+//       for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ ) {
+//      G4UIcommand* cmd = commands[i_thCommand];
+//      G4cout << cmd->GetCommandName() << G4endl; 
+//       }
+//       return empty;
+//     }
+//     // Look for sub tree :
+//     std::vector<G4UIcommandTree*> trees;
+//     G4String nextPath = pathName;
+//     nextPath.append(remainingPath);
+//     G4int n_treeEntry = aTree->GetTreeEntry();
+//     for( G4int i_thTree = 1; i_thTree <= n_treeEntry; i_thTree++ ) {
+//       G4UIcommandTree* tree = aTree->GetTree(i_thTree);
+//       G4String ss = tree->GetPathName();
+//       ss.resize(nextPath.length());
+//       if( nextPath == ss ) trees.push_back(tree);
+//     }
+//     n_treeEntry = trees.size();
+//     if(n_treeEntry==1) {
+//       return trees[0]->GetPathName();
+//     } else if (n_treeEntry>=2) {
+//       G4cout << "Matching directories :" << G4endl; 
+//       for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ ) {
+//      G4UIcommandTree* tree = trees[i_thTree];
+//      G4cout << tree->GetPathName() << G4endl; 
+//       }
+//       return empty;
+//     } else {
+//       return empty; // No match.
+//     }
+//   } else {
+//     // Find path
+//     G4String nextPath = pathName;
+//     nextPath.append(remainingPath(0,i+1));
+//     G4int n_treeEntry = aTree->GetTreeEntry();
+//     for( G4int i_thTree = 1; i_thTree <= n_treeEntry; i_thTree++ ) {
+//       G4UIcommandTree* tree = aTree->GetTree(i_thTree);
+//       if( nextPath == tree->GetPathName() ) { 
+//      return tree->CompleteCommandPath(pathName ); 
+//       }
+//     }
+//   }
+  //  n_commandEntry = commands.size();
+  return stream;
+}
+
+
+////////////////////////////////////////////////////////////////////
+G4String G4UIcommandTree::GetFirstMatchedString(const G4String& str1, 
+                                         const G4String& str2) const
+////////////////////////////////////////////////////////////////////
+{
+  int nlen1= str1.length();
+  int nlen2= str2.length();
+
+  int nmin = nlen1<nlen2 ? nlen1 : nlen2;
+
+  G4String strMatched;
+  for(size_t i=0; G4int(i)<nmin; i++){
+    if(str1[i]==str2[i]) {
+      strMatched+= str1[i];
+    } else {
+      break;
+    }
+  }
+
+  return strMatched;
+}
+
+
+
 
 void G4UIcommandTree::ListCurrent()

trunk/source/interfaces/basic/src/G4VUIshell.cc

@@ -149 +149 @@
 //////////////////////////////////////////////////////////////////////
 {
+  printf("G4VUIshell::GetAbsCommandDirPath %s\n",apath.c_str());
   if(apath.empty()) return apath;  // null string
 
@@ -157 +158 @@
 
   // parsing...
+  printf("G4VUIshell::GetAbsCommandDirPath bpath %s\n",bpath.c_str());
   G4String absPath= "/";
+  printf("G4VUIshell::GetAbsCommandDirPath num %d \n",G4int(bpath.length())-1);
   for(G4int indx=1; indx<=G4int(bpath.length())-1; ) {
+    printf("G4VUIshell::GetAbsCommandDirPath for %d/%d \n",indx,G4int(bpath.length())-1);
     G4int jslash= bpath.index("/", indx);  // search index begin with "/"
     if(jslash != G4int(G4String::npos)) {
@@ -177 +181 @@
     indx= jslash+1;
   }
+  printf("G4VUIshell::GetAbsCommandDirPath RETURN %s\n",absPath.c_str());
   return  absPath;
 }

trunk/source/interfaces/common/include/G4VBasicShell.hh

@@ -85 +85 @@
     G4String Complete(G4String);
     // command completion
+
+    G4String CompleteCommand(G4String);
+    // command completion
     G4String FindMatchingPath(G4UIcommandTree*,G4String);
 

trunk/source/interfaces/common/src/G4VBasicShell.cc

@@ -180 +180 @@
   return value;
 }
+
+
+
+
 G4String G4VBasicShell::FindMatchingPath(
  G4UIcommandTree* aTree
@@ -186 +190 @@
 // From intercoms/src/G4UIcommandTree::FindPath.
 {
+  return aTree->CompleteCommandPath(aCommandPath);
+
 #ifdef G4DEBUG
   printf("G4VBasicShell::FindMatchingPath %s\n",aCommandPath.c_str());
@@ -226 +232 @@
         G4UIcommand* cmd = commands[i_thCommand];
         G4cout << cmd->GetCommandName() << G4endl; 
+#ifdef G4DEBUG
+        printf("%s found\n",cmd->GetCommandName().c_str());
+#endif
       }
       return empty;
@@ -258 +267 @@
     nextPath.append(remainingPath(0,i+1));
     G4int n_treeEntry = aTree->GetTreeEntry();
+#ifdef G4DEBUG
+    printf(" find PATH\n");
+#endif
     for( G4int i_thTree = 1; i_thTree <= n_treeEntry; i_thTree++ ) {
       G4UIcommandTree* tree = aTree->GetTree(i_thTree);
+#ifdef G4DEBUG
+      printf("++++LOOP+++++++++++++%s == %s \n",nextPath.c_str(), tree->GetPathName().c_str());
+#endif
       if( nextPath == tree->GetPathName() ) { 
         return FindMatchingPath(tree,aCommandPath );