private QueryFilter ParseOrOp(XmlNode parentNode)
        {
            List <QueryFilter> list = new List <QueryFilter>();

            foreach (object obj in parentNode.ChildNodes)
            {
                XmlNode     node = (XmlNode)obj;
                QueryFilter item = this.ParseSearchNamespace(node);
                list.Add(item);
            }
            return(MailboxSearchCriteriaBuilder.ConstructAndOrOperator(list, "Or"));
        }
        private QueryFilter ParseSearchNamespace(XmlNode node)
        {
            if ("Search:" != node.NamespaceURI)
            {
                throw new SearchProtocolErrorException
                      {
                          ErrorStringForProtocolLogger = "SearchProtocolError11"
                      };
            }
            string name;

            switch (name = node.Name)
            {
            case "FreeText":
                return(this.ParseFreeText(node));

            case "LessThan":
            case "GreaterThan":
                return(MailboxSearchCriteriaBuilder.ParseLtGtOperator(node));

            case "ConversationId":
                return(this.ParseConversationId(node));

            case "Contains":
                return(this.ParseContains(node));

            case "DoesNotContain":
                return(this.ParseDoesNotContain(node));

            case "Or":
                return(this.ParseOrOp(node));
            }
            throw new SearchProtocolErrorException
                  {
                      ErrorStringForProtocolLogger = "BadNode(" + node.Name + ")InSearch"
                  };
        }
        public QueryFilter ParseTopLevelClassAndFolders(XmlNode queryNode, bool contentIndexingEnabled, IAirSyncVersionFactory versionFactory, IAirSyncContext context)
        {
            this.Clear();
            if (queryNode.ChildNodes.Count != 1)
            {
                throw new SearchFilterTooComplexException
                      {
                          ErrorStringForProtocolLogger = "SearchTooComplexError1"
                      };
            }
            XmlNode xmlNode = queryNode.ChildNodes[0];

            if ("Search:" != xmlNode.NamespaceURI || "And" != xmlNode.Name)
            {
                throw new SearchFilterTooComplexException
                      {
                          ErrorStringForProtocolLogger = "SearchTooComplexError1"
                      };
            }
            List <string>  list  = new List <string>();
            List <string>  list2 = new List <string>();
            List <XmlNode> list3 = new List <XmlNode>();

            this.contentIndexingEnabled = contentIndexingEnabled;
            foreach (object obj in xmlNode.ChildNodes)
            {
                XmlNode xmlNode2 = (XmlNode)obj;
                if ("AirSync:" == xmlNode2.NamespaceURI && "CollectionId" == xmlNode2.Name)
                {
                    if (xmlNode2.ChildNodes.Count != 1 || xmlNode2.FirstChild.NodeType != XmlNodeType.Text)
                    {
                        throw new SearchProtocolErrorException
                              {
                                  ErrorStringForProtocolLogger = "SearchProtocolError1"
                              };
                    }
                    list2.Add(xmlNode2.InnerText);
                }
                else if ("AirSync:" == xmlNode2.NamespaceURI && "Class" == xmlNode2.Name)
                {
                    if (xmlNode2.ChildNodes.Count != 1 || xmlNode2.FirstChild.NodeType != XmlNodeType.Text)
                    {
                        throw new SearchProtocolErrorException
                              {
                                  ErrorStringForProtocolLogger = "SearchProtocolError2"
                              };
                    }
                    list.Add(xmlNode2.InnerText);
                }
                else
                {
                    list3.Add(xmlNode2);
                }
            }
            if (list3.Count < 1)
            {
                throw new SearchProtocolErrorException
                      {
                          ErrorStringForProtocolLogger = "SearchProtocolError3"
                      };
            }
            this.folderScope    = list2;
            this.airSyncClasses = list;
            this.schemaCache    = new Dictionary <string, MailboxSearchCriteriaBuilder.SchemaCacheItem>();
            List <QueryFilter> list4 = new List <QueryFilter>();

            new List <QueryFilter>();
            if (list.Count == 0)
            {
                list.Add("Email");
                list.Add("Calendar");
                list.Add("Contacts");
                list.Add("Tasks");
                if (context.Request.Version >= 140)
                {
                    list.Add("Notes");
                    list.Add("SMS");
                }
            }
            foreach (string text in list)
            {
                string key;
                switch (key = text)
                {
                case "Email":
                    this.schemaCache["Email"] = new MailboxSearchCriteriaBuilder.SchemaCacheItem(versionFactory.CreateEmailSchema(null), versionFactory.CreateMissingPropertyStrategy(null));
                    continue;

                case "Calendar":
                    this.schemaCache["Calendar"] = new MailboxSearchCriteriaBuilder.SchemaCacheItem(versionFactory.CreateCalendarSchema(), versionFactory.CreateMissingPropertyStrategy(null));
                    continue;

                case "Contacts":
                    this.schemaCache["Contacts"] = new MailboxSearchCriteriaBuilder.SchemaCacheItem(versionFactory.CreateContactsSchema(), versionFactory.CreateMissingPropertyStrategy(null));
                    continue;

                case "Tasks":
                    this.schemaCache["Tasks"] = new MailboxSearchCriteriaBuilder.SchemaCacheItem(versionFactory.CreateTasksSchema(), versionFactory.CreateMissingPropertyStrategy(null));
                    continue;

                case "Notes":
                    if (context.Request.Version < 140)
                    {
                        throw new SearchProtocolErrorException
                              {
                                  ErrorStringForProtocolLogger = "SearchProtocolError4"
                              };
                    }
                    this.schemaCache["Notes"] = new MailboxSearchCriteriaBuilder.SchemaCacheItem(versionFactory.CreateNotesSchema(), versionFactory.CreateMissingPropertyStrategy(null));
                    continue;

                case "SMS":
                    if (context.Request.Version < 140)
                    {
                        throw new SearchProtocolErrorException
                              {
                                  ErrorStringForProtocolLogger = "SearchProtocolError5"
                              };
                    }
                    this.schemaCache["SMS"] = new MailboxSearchCriteriaBuilder.SchemaCacheItem(versionFactory.CreateSmsSchema(), versionFactory.CreateMissingPropertyStrategy(null));
                    continue;
                }
                throw new SearchProtocolErrorException
                      {
                          ErrorStringForProtocolLogger = "SearchProtocolError6"
                      };
            }
            foreach (XmlNode node in list3)
            {
                QueryFilter queryFilter = this.ParseSearchNamespace(node);
                if (queryFilter == null)
                {
                    return(null);
                }
                list4.Add(queryFilter);
            }
            return(MailboxSearchCriteriaBuilder.ConstructAndOrOperator(list4, "And"));
        }