First draft of wildcard functions. For issue #58.

end2endzone · end2endzone · commit a98b66d9fbf9 · 2020-08-13T17:21:01.000-04:00
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -75,6 +75,8 @@ add_library(shellanything STATIC
   ErrorManager.cpp
   PropertyManager.h
   PropertyManager.cpp
+  Wildcard.cpp
+  Wildcard.h
 )
 
 add_library(shellext SHARED
diff --git a/src/Wildcard.cpp b/src/Wildcard.cpp
@@ -0,0 +1,269 @@
+/**********************************************************************************
+ * MIT License
+ * 
+ * Copyright (c) 2018 Antoine Beauchamp
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *********************************************************************************/
+
+//#define _CRTDBG_MAP_ALLOC
+//#include <stdlib.h>
+//#include <crtdbg.h>
+
+#include "Wildcard.h"
+
+namespace shellanything
+{
+
+  bool IsWildcard(char c)
+  {
+    if (c == '*' || c == '?')
+      return true;
+    return false;
+  }
+
+  int getNextWildcardPosition(const IntList & iPositions, int iSourceWildcardPosition)
+  {
+    for(unsigned int i=0; i<iPositions.size(); i++)
+    {
+      const int & pos = iPositions[i];
+      if (pos == iSourceWildcardPosition)
+      {
+        if (i+1 < iPositions.size())
+        {
+          return iPositions[i+1];
+        }
+        return -1; //requested wildcard is the last one
+      }
+    }
+    return -1; //wildcard position not found
+  }
+
+  void FindWildcardCharacters(const char * iString, int iOffset, IntList & oIndexes)
+  {
+    oIndexes.clear();
+    int len = (int)std::string(iString).size();
+    for(int i=iOffset; i<len; i++)
+      if ( IsWildcard(iString[i]) )
+        oIndexes.push_back(i);
+  }
+
+  bool HasWildcardCharacters(const char * iValue)
+  {
+    IntList positions;
+    FindWildcardCharacters(iValue, 0, positions);
+    return positions.size() > 0;
+  }
+
+  bool WildcardSolve( const char * iWildcard,
+                      const char * iValue,
+                      const IntList & iWildcardPositions,
+                      const int iIndexWild,
+                      const int iIndexValue,
+                      WildcardList & oList                     )
+  {
+    int indexWild = iIndexWild;
+    int indexValue = iIndexValue;
+    int wildLen   = (int)std::string(iWildcard).size();
+    int valueLen  = (int)std::string(iValue).size();
+  
+    //while wildcard and value not fully solved
+    while (indexWild < wildLen || indexValue < valueLen)
+    {
+      const char & cWild  = iWildcard[indexWild];
+      const char & cValue = iValue[indexValue];
+      if ( !IsWildcard(cWild) )
+      {
+        if (cWild != cValue)
+          return false; //characters don't match!
+
+        //next char
+        indexWild++;
+        indexValue++;
+      }
+      else
+      {
+        //cWild is wildcard
+        if (cWild == '?')
+        {
+          //save wildcard resolve information
+          WILDCARD w;
+          w.character = cWild;
+          w.index = indexWild;
+          w.value = cValue;
+          oList.push_back(w);
+
+          //next char
+          indexWild++;
+          indexValue++;
+        }
+        else if (cWild == '*')
+        {
+          //if wildcard character * is the last one
+          if (indexWild+1 >= wildLen)
+          {
+            //automatically match the end of the string
+
+            //save wildcard resolve information
+            WILDCARD w;
+            w.character = cWild;
+            w.index = indexWild;
+            w.value = &cValue;
+            oList.push_back(w);
+
+            //next char
+            indexWild++;
+            indexValue += (int)w.value.size();
+          }
+          else
+          {
+            //wildcard character * is not the last one
+
+            //compute all possibilities that can fit in * and then use recursion to check if it can be resolved
+            //compute the possibilities in the from the longest to the shortest ("") for optimizing the replacement string
+            //since all wildcard caracters must be mapped, do not compute possibilities beyond the next wildcard character
+
+
+            //compute next character
+            const char & nextWild = (&cWild)[1];
+
+            int nextWildcardPosition = getNextWildcardPosition(iWildcardPositions, indexWild);
+
+            //compute fixed characters between this wildcard and the last one (of the end of the file)
+            //ie: fgh in abc*fgh?j or abc*fgh
+            std::string fixedCharacters = &nextWild;
+            if (nextWildcardPosition != -1)
+            {
+              //there is at least another wildcard character after this one
+              fixedCharacters = &nextWild;
+              size_t size = nextWildcardPosition - indexWild;
+              fixedCharacters.resize(size);
+            }
+
+            //compute maximum length of replacementString
+            int remainingCharactersInValue = valueLen-indexValue;
+            int replacementStringMaxLength = remainingCharactersInValue-(int)fixedCharacters.size();
+
+            //compute all possibilities that can fit in * with a length in [0,replacementStringMaxLength]
+            for(int length=replacementStringMaxLength; length>=0; length--)
+            {
+              //assuming replacement string is the right one
+
+              std::string replacementString = &cValue;
+              replacementString.resize(length);
+
+              WildcardList tmpList = oList;
+
+              //save wildcard resolve information
+              WILDCARD w;
+              w.character = cWild;
+              w.index = indexWild;
+              w.value = replacementString;
+              tmpList.push_back(w);
+
+              //next char
+              int tmpIndexWild = indexWild+1;
+              int tmpIndexValue = indexValue + (int)w.value.size();
+
+              //execute recursive call
+              bool solved = WildcardSolve(iWildcard, iValue, iWildcardPositions, tmpIndexWild, tmpIndexValue, tmpList);
+              if (solved)
+              {
+                //solved!
+                //refresh oList
+                oList = tmpList;
+                return true;
+              }
+            }
+
+            //all possibilities were checked
+            //unable to solve * wildcard
+            return false;
+          }
+        }
+      }
+    }
+
+    if (indexWild == wildLen && indexValue == valueLen)
+      return true; //solved
+    if ((indexWild == wildLen && indexValue < valueLen) ||
+        (indexWild == wildLen && indexValue < valueLen)     )
+      return false; //reached the end of wildcard or the end of value
+    return false; //???
+  }
+
+  bool WildcardSolve(const char * iWildcard, const char * iValue, WildcardList & oList)
+  {
+    oList.clear();
+    int indexWild = 0;
+    int indexValue = 0;
+
+    //find all wildcard character positions
+    IntList wildcardPositions;
+    FindWildcardCharacters(iWildcard, 0, wildcardPositions);
+
+    //if no wildcard character, strings must be equal
+    if (wildcardPositions.size() == 0)
+      return (std::string(iWildcard) == std::string(iValue));
+
+    //solve wildcards
+    return WildcardSolve(iWildcard, iValue, wildcardPositions, indexWild, indexValue, oList);
+  }
+
+  bool WildcardMatch(const char * iWildcard, const char * iValue)
+  {
+    WildcardList dummy;
+    return WildcardSolve(iWildcard, iValue, dummy);
+  }
+
+  WildcardGroupList FindWildcardGroups(const char * iString)
+  {
+    WildcardGroupList groups;
+
+    IntList positions;
+    FindWildcardCharacters(iString, 0, positions);
+    for(size_t i=0; i<positions.size(); i++)
+    {
+      int & pos = positions[i];
+      char c = iString[pos];
+
+      //add current wildcard type to list
+      bool found = false;
+      for(size_t j=0; j<groups.size(); j++)
+      {
+        if (groups[j].character == c)
+        {
+          groups[j].indexes.push_back(pos);
+          found = true;
+        }
+      }
+      if (!found)
+      {
+        //create a new one
+        WILDCARD_GROUP g;
+        g.character = c;
+        g.indexes.push_back(pos);
+        groups.push_back(g);
+      }
+    }
+
+    return groups;
+  }
+
+} //namespace shellanything
diff --git a/src/Wildcard.h b/src/Wildcard.h
@@ -0,0 +1,96 @@
+/**********************************************************************************
+ * MIT License
+ * 
+ * Copyright (c) 2018 Antoine Beauchamp
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *********************************************************************************/
+
+#ifndef SA_WILDCARD_H
+#define SA_WILDCARD_H
+
+#include <string>
+#include <vector>
+
+namespace shellanything
+{
+
+  /// <summary>
+  /// Defines a wildcard expansion solution to match a given string.
+  /// </summary>
+  struct WILDCARD
+  {
+    ///<summary>The wildcard character found in the given string.</summary>
+    char character;
+
+    ///<summary>The index at which the wildcard character was found.</summary>
+    int index;
+
+    ///<summary>The expanded value of the wildcard to match the given string.</summary>
+    std::string value;
+  };
+
+  /// <summary>
+  /// Defines a list of WILDCARD
+  /// </summary>
+  typedef std::vector<WILDCARD> WildcardList;
+
+  typedef std::vector<int> IntList;
+
+  struct WILDCARD_GROUP
+  {
+    char character;
+    IntList indexes;
+  };
+  typedef std::vector<WILDCARD_GROUP> WildcardGroupList;
+
+  /// <summary>
+  /// Evaluates if the given character is a wildcard character supported by the library.
+  /// </summary>
+  /// <param name="c">The character to evaluate.</param>
+  /// <returns>Returns true if the given character is a wildcard character. Returns false otherwise.</returns>
+  bool IsWildcard(char c);
+
+  /// <summary>
+  /// Evaluates if the given string contains at least one wildcard character.
+  /// </summary>
+  /// <param name="c">The string to evaluate.</param>
+  /// <returns>Returns true when the given string contains at least one wildcard character. Returns false otherwise.</returns>
+  bool HasWildcardCharacters(const char * iValue);
+
+  /// <summary>
+  /// Returns the position of each wildcard character into oIndexes from iString starting at iOffset.
+  /// </summary>
+  /// <param name="iString">The string to search.</param>
+  /// <param name="iOffset">The index in the string where to start the search from.</param>
+  /// <param name="oIndexes">The offsets where wildcard characters was found.</param>
+  void FindWildcardCharacters(const char * iString, int iOffset, IntList & oIndexes);
+
+  //Processes iWildcard and finds expanding parameters in order to convert iWildcard to iValue
+  bool WildcardSolve(const char * iWildcard, const char * iValue, WildcardList & oList);
+
+  //Returns true if iWildcard can be expanded to match iValue.
+  bool WildcardMatch(const char * iWildcard, const char * iValue);
+
+  //Returns all wildcard characters and index from iString groupped by wildcard character
+  WildcardGroupList FindWildcardGroups(const char * iString);
+
+} //namespace shellanything
+
+#endif //SA_ACTION_PROPERTY_H
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -81,6 +81,8 @@ add_executable(shellanything_unittest
   TestUnicode.h
   TestValidator.cpp
   TestValidator.h
+  TestWildcard.h
+  TestWildcard.cpp
   TestWin32Registry.cpp
   TestWin32Registry.h
   TestWin32Utils.cpp
diff --git a/test/TestWildcard.cpp b/test/TestWildcard.cpp
diff --git a/test/TestWildcard.h b/test/TestWildcard.h

Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,8 @@ add_library(shellanything STATIC`
`75`	`75`	`ErrorManager.cpp`
`76`	`76`	`PropertyManager.h`
`77`	`77`	`PropertyManager.cpp`
	`78`	`+ Wildcard.cpp`
	`79`	`+ Wildcard.h`
`78`	`80`	`)`
`79`	`81`
`80`	`82`	`add_library(shellext SHARED`