Example #1
0
        private int RegexQueryNrHits(String regex, IRegexCapabilities capability)
        {
            RegexQuery query = new RegexQuery(NewTerm(regex));

            if (capability != null)
                query.RegexImplementation = capability;

            return searcher.Search(query, null, 1000).TotalHits;
        }
        public void TestEquals()
        {
            RegexQuery query1 = new RegexQuery(NewTerm("foo.*"));
            //query1.SetRegexImplementation(new JakartaRegexpCapabilities());

            RegexQuery query2 = new RegexQuery(NewTerm("foo.*"));

            Assert.True(query1.Equals(query2));
        }
        private int RegexQueryNrHits(String regex, IRegexCapabilities capability)
        {
            RegexQuery query = new RegexQuery(NewTerm(regex));

            if (capability != null)
            {
                query.RegexImplementation = capability;
            }

            return(searcher.Search(query, null, 1000).TotalHits);
        }
            public override bool Equals(object obj)
            {
                if (!(obj is RegexQuery))
                {
                    return(false);
                }

                RegexQuery other = obj as RegexQuery;

                return(string.Equals(pattern, other.pattern) && string.Equals(input, other.input));
            }
        public RegexQueryInstance CreateRegexQuery(string fieldName, string text)
        {
            var query = new RegexQuery
            {
                Term = new Term
                {
                    FieldName = fieldName,
                    Value     = text
                }
            };

            return(new RegexQueryInstance(Engine.Object.InstancePrototype, query));
        }
        private bool LookupRegexCache(ProcessHook hook, string cmd)
        {
            bool isMatch = false;
            var  query   = new RegexQuery(hook.CommandLineRegx, cmd);

            if (_regxCache.ContainsKey(query))
            {
                isMatch = _regxCache[query];
            }
            else
            {
                isMatch = Regex.IsMatch(cmd, hook.CommandLineRegx);

                _regxCache.Add(query, isMatch);
            }

            return(isMatch);
        }
Example #7
0
        private Material[] LoadMaterials(string aseAssetName, IGeometryContext context, IFormatProvider format, string data)
        {
            var materials = new List <Material>();

            var rootPath = Path.GetDirectoryName(aseAssetName);

            var query = from match in RegexQuery.Against(data)
                        where   match
                        .RegEx("\t")
                        .Literal("*MATERIAL")
                        .WhiteSpace
                        .Group(Pattern.With.Digit.Repeat.ZeroOrMore)
                        .WhiteSpace
                        .Literal("{")
                        .RegEx("[\n\r]*")
                        .IsTrue()
                        select match;

            foreach (var match in query)
            {
                var materialEnd = data.IndexOf("\n\t}", match.Index);
                if (materialEnd > 0)
                {
                    materialEnd += 2;
                    var material = new Material();
                    materials.Add(material);
                    var materialString = data.Substring(match.Index, materialEnd - match.Index);
                    var diffuseIndex   = materialString.IndexOf("\t\t*MAP_DIFFUSE");
                    if (diffuseIndex > 0)
                    {
                        var diffuseEnd = materialString.IndexOf("\n\t\t}", diffuseIndex);
                        if (diffuseEnd > 0)
                        {
                            var diffuseString = materialString.Substring(diffuseIndex, diffuseEnd - diffuseIndex);
                            var bitmapIndex   = diffuseString.IndexOf("\t\t\t*BITMAP");
                            var eolIndex      = diffuseString.IndexOf('\n', bitmapIndex);
                            if (eolIndex > 0)
                            {
                                var bitmapString = diffuseString.Substring(bitmapIndex, eolIndex - bitmapIndex);
                                var fileIndex    = bitmapString.IndexOf('"');
                                if (fileIndex > 0)
                                {
                                    var file         = bitmapString.Substring(fileIndex + 1).Replace('"', ' ').Trim();
                                    var relativeFile = Path.GetFileName(file);
                                    var actualFile   = string.IsNullOrEmpty(rootPath)
                                                                                                ? relativeFile
                                                                                                : string.Format("{0}//{1}", rootPath, relativeFile);
                                    var loader = _assetLoaderService.GetLoader <Image>(actualFile);
                                    var frames = loader.Load(actualFile);
                                    material.DiffuseMap = frames[0];
                                }
                            }
                        }
                    }
                }
            }
            return(materials.ToArray());

            /*
             * var materialRegex = new Regex(@"\t\*MATERIAL\s*(\d*)\s*{[\n\r](.*)\t}");
             * var matches = materialRegex.Matches(data);
             *
             * var assetName = "BlueEnvMap.png";
             * var loader = AssetLoaderManager.Instance.GetLoader<Image>(assetName);
             * var frames = loader.Load(assetName);
             *
             * var material = new Material
             *                              {
             *                                      DiffuseMap = frames[0]
             *                              };
             *
             * for (var faceIndex = 0; faceIndex < context.FaceCount; faceIndex++)
             * {
             *      context.SetMaterial(faceIndex, material);
             * }
             */
        }
Example #8
0
        public void TestEquals()
        {
            RegexQuery query1 = new RegexQuery(NewTerm("foo.*"));
            //query1.SetRegexImplementation(new JakartaRegexpCapabilities());

            RegexQuery query2 = new RegexQuery(NewTerm("foo.*"));
            Assert.True(query1.Equals(query2));
        }
 private static void MultiTermQuery(RegexQuery query, AzureQueryLogger.IndentedTextWriter writer)
 {
     writer.WriteLine("RegexImplementation: {0}", query.RegexImplementation);
     AzureQueryLogger.VisitTerm(query.Term, "Regex Term", writer);
 }
Example #10
0
 private static void MultiTermQuery(RegexQuery query, AzureQueryLogger.IndentedTextWriter writer)
 {
     writer.WriteLine("RegexImplementation: {0}", query.RegexImplementation);
     AzureQueryLogger.VisitTerm(query.Term, "Regex Term", writer);
 }
Example #11
0
        public List <string> QueryAutoComplete(string searchTerm)
        {
            Query query = new RegexQuery(new Term(F_TAGNAME, ".*" + searchTerm + ".*"));

            return(GetByQuery(F_TAGNAME, query));
        }