Example #1
0
        /// <summary>
        /// Performs a raw, unfiltered search at the SPI level,
        /// eliminating duplicates from the result set.
        /// </summary>
        /// <param name="search">The search SPI</param>
        /// <param name="oclass">The object class - passed through to
        /// connector so it may be null if the connecor
        /// allowing it to be null. (This is convenient for
        /// unit tests, but will not be the case in general)</param>
        /// <param name="filter">The filter to search on</param>
        /// <param name="handler">The result handler</param>
        /// <param name="options">The options - may be null - will
        /// be cast to an empty OperationOptions</param>
        public SearchResult Search <T>(SearchOp <T> search,
                                       ObjectClass objectClass,
                                       Filter filter,
                                       ResultsHandler handler,
                                       OperationOptions options) where T : class
        {
            Assertions.NullCheck(objectClass, "objectClass");
            if (ObjectClass.ALL.Equals(objectClass))
            {
                throw new System.NotSupportedException("Operation is not allowed on __ALL__ object class");
            }
            Assertions.NullCheck(handler, "handler");
            //convert null into empty
            if (options == null)
            {
                options = new OperationOptionsBuilder().Build();
            }

            SearchResult result = null;

            RawSearcherImpl <T> .RawSearch(search, objectClass, filter, new SearchResultsHandler()
            {
                Handle = obj =>
                {
                    return(handler.Handle(obj));
                },
                HandleResult = obj =>
                {
                    result = obj;
                }
            }, options);

            return(result != null ? result : new SearchResult());
        }
Example #2
0
 /// <summary>
 /// Performs a raw, unfiltered search at the SPI level,
 /// eliminating duplicates from the result set.
 /// </summary>
 /// <param name="search">The search SPI</param>
 /// <param name="oclass">The object class - passed through to
 /// connector so it may be null if the connecor
 /// allowing it to be null. (This is convenient for
 /// unit tests, but will not be the case in general)</param>
 /// <param name="filter">The filter to search on</param>
 /// <param name="handler">The result handler</param>
 /// <param name="options">The options - may be null - will
 /// be cast to an empty OperationOptions</param>
 public static void Search <T>(SearchOp <T> search,
                               ObjectClass oclass,
                               Filter filter,
                               ResultsHandler handler,
                               OperationOptions options) where T : class
 {
     GetSpi().Search(search, oclass, filter, handler, options);
 }
Example #3
0
        /// <summary>
        /// Performs a raw, unfiltered search at the SPI level,
        /// eliminating duplicates from the result set.
        /// </summary>
        /// <param name="search">The search SPI</param>
        /// <param name="oclass">The object class - passed through to
        /// connector so it may be null if the connecor
        /// allowing it to be null. (This is convenient for
        /// unit tests, but will not be the case in general)</param>
        /// <param name="filter">The filter to search on</param>
        /// <param name="options">The options - may be null - will
        /// be cast to an empty OperationOptions</param>
        /// <returns>The list of results.</returns>
        public static IList <ConnectorObject> SearchToList <T>(SearchOp <T> search,
                                                               ObjectClass oclass,
                                                               Filter filter,
                                                               OperationOptions options) where T : class
        {
            ToListResultsHandler handler = new
                                           ToListResultsHandler();

            Search(search, oclass, filter, handler.ResultsHandler, options);
            return(handler.Objects);
        }
Example #4
0
 /// <summary>
 /// Performs a raw, unfiltered search at the SPI level,
 /// eliminating duplicates from the result set.
 /// </summary>
 /// <param name="search">The search SPI</param>
 /// <param name="oclass">The object class - passed through to
 /// connector so it may be null if the connecor
 /// allowing it to be null. (This is convenient for
 /// unit tests, but will not be the case in general)</param>
 /// <param name="filter">The filter to search on</param>
 /// <param name="handler">The result handler</param>
 /// <param name="options">The options - may be null - will
 /// be cast to an empty OperationOptions</param>
 public void Search <T>(SearchOp <T> search,
                        ObjectClass oclass,
                        Filter filter,
                        ResultsHandler handler,
                        OperationOptions options) where T : class
 {
     if (options == null)
     {
         options = new OperationOptionsBuilder().Build();
     }
     RawSearcherImpl <T> .RawSearch(
         search, oclass, filter, handler, options);
 }
Example #5
0
    public static void GetCollisionNodes( )
    {
        Store.Initialize(SimiasDataPath, true, -1);
        Store store = Store.GetStore();

        if (store == null)
        {
            Console.WriteLine("store could not be initialized.....");
        }
        Domain domain = store.GetDomain(store.DefaultDomain);

        SearchOp searchOperation = SearchOp.Begins;
        string   pattern         = "*";
        int      max             = 0;
        int      index           = 0;

        Console.WriteLine();
        Console.WriteLine("**************************Collision Nodes Report********************* ");
        Console.WriteLine();

        Simias.Storage.SearchPropertyList SearchPrpList = new Simias.Storage.SearchPropertyList();
        int i = 0;

        SearchPrpList.Add(CollisionProperty, "*", SearchOp.Exists);
        SearchPrpList.Add(BaseSchema.ObjectName, pattern, searchOperation);
        try{
            ICSList searchList = Catalog.Search(SearchPrpList);

            SearchState searchState = new SearchState(domain.ID, searchList.GetEnumerator() as ICSEnumerator, searchList.Count);
            if (index != 0)
            {
                searchState.Enumerator.SetCursor(Simias.Storage.Provider.IndexOrigin.SET, index);
            }
            foreach (ShallowNode sn in searchList)
            {
                if (max != 0 && i++ >= max)
                {
                    break;
                }
                CatalogEntry catEntry = Catalog.ConvertToCataloEntry(sn);
                Console.WriteLine("iFolder Name :{0}, iFolder ID:{1}", catEntry.Name, catEntry.CollectionID);
            }
        }
        catch (Exception ee)
        {
            Console.WriteLine("Got exception: " + ee.Message);
        }
        finally{
            Store.DeleteInstance();
        }
    }
Example #6
0
        /// <summary>
        /// Construct a Query object that can be used to perform a search.
        /// </summary>
        /// <param name="collectionId">The Collection to perform the search in.</param>
        /// <param name="property">The property that contains the value.</param>
        /// <param name="op">The operator used for the match criteria.</param>
        /// <param name="value">The value to match.</param>
        /// <param name="type">The Type of the value to search for.</param>
        public Query(string collectionId, string property, SearchOp op, string value, Syntax type)
        {
            this.collectionId = collectionId;
            this.property     = property;
            this.operation    = op;
            this.type         = type;

            if (type == Syntax.Boolean)
            {
                this.value =
                    (String.Compare(value, "true", true) == 0 ||
                     String.Compare(value, "1", false) == 0) ? "1" : "0";
            }
            else
            {
                this.value = value;
            }
        }
Example #7
0
        /// <summary>
        /// Method to search for the specified value for the given property.
        /// </summary>
        /// <param name="name">Property to search</param>
        /// <param name="op">Query operation</param>
        /// <param name="value">Value to match</param>
        /// <param name="type">The type of the value.</param>
        /// <param name="shouldMatch">If true the search should return a result.</param>
        private void internalSearch(string name, SearchOp op, string value, Syntax type, bool shouldMatch)
        {
            IResultSet results;
            bool       foundMatch = false;

            //results = provider.Search(new Query(name, op, value, type));
            results = provider.Search(new Query(collectionId, name, op, value, type));
            if (results != null)
            {
                char [] buf = new char[4096];
                int     len;
                while ((len = results.GetNext(ref buf)) != 0)
                {
                    foundMatch = true;
                    //writeXml(new string(buf, 0, len));
                }
                if ((shouldMatch && !foundMatch) || (!shouldMatch && foundMatch))
                {
                    Console.WriteLine(string.Format("Failed searching for \"{0}\" {1} \"{2}\" type = {3}", name, op.ToString(), value, type));
                    //throw (new ApplicationException(string.Format("Searching for \"{0}\" {1} \"{2}\" type = {3}", name, op.ToString(), value, type)));
                }
                results.Dispose();
            }
        }
    public static void GetCollisionNodes( )
    {
        Store.Initialize(SimiasDataPath, true, -1);
        Store store = Store.GetStore();

        if (store == null)
        {
            Console.WriteLine("store could not be initialized.....");
        }
        Domain domain = store.GetDomain(store.DefaultDomain);

        SearchOp searchOperation = SearchOp.Begins;
        string   pattern         = "*";
        int      max             = 0;
        int      index           = 0;

        //create catalog instances
        catalog = store.GetCollectionByID(catalogID);
        if (catalog == null)
        {
            Console.WriteLine("Could not get the catalog collection node from store... Exiting");
            return;
        }

        Console.WriteLine();
        Console.WriteLine("**************************Collision Nodes Deletion********************* ");
        Console.WriteLine();

        Simias.Storage.SearchPropertyList SearchPrpList = new Simias.Storage.SearchPropertyList();
        int i = 0;

        SearchPrpList.Add(CollisionProperty, "*", SearchOp.Exists);
        SearchPrpList.Add(BaseSchema.ObjectName, pattern, searchOperation);
        ICSList searchList = Catalog.Search(SearchPrpList);

        try{
            SearchState searchState = new SearchState(domain.ID, searchList.GetEnumerator() as ICSEnumerator, searchList.Count);
            if (index != 0)
            {
                searchState.Enumerator.SetCursor(Simias.Storage.Provider.IndexOrigin.SET, index);
            }
            if (searchList != null && searchList.Count > 0)
            {
                Console.WriteLine("Catalog entry for all collision nodes will be deleted from Catalog Collection Node, Type yes to continue.");
                Console.WriteLine();
                string entered = Console.ReadLine();
                if (String.Equals(entered.ToLower(), "yes"))
                {
                    foreach (ShallowNode sn in searchList)
                    {
                        if (max != 0 && i++ >= max)
                        {
                            break;
                        }
                        CatalogEntry catEntry = Catalog.ConvertToCataloEntry(sn);
                        Console.WriteLine("Deleting catalog with iFolder Name :{0}, iFolder ID:{1}", catEntry.Name, catEntry.CollectionID);
                        catalog.Commit(catalog.Delete(catEntry));
                        Thread.Sleep(100);
                    }
                    Console.WriteLine();
                    Console.WriteLine("Total number of deleted nodes: " + i);
                }
            }
            else
            {
                Console.WriteLine("No catalog node was found with collision!");
            }
        }catch (Exception ee)
        {
            Console.WriteLine("Got this exception: " + ee.Message);
        }
        finally{
            Store.DeleteInstance();
        }
    }
Example #9
0
 public static GaimBuddy[] SearchForBuddies(string attributeName, string searchString, SearchOp operation)
 {
     ArrayList buddies = new ArrayList();
        GaimBuddy[] allBuddies = allBuddies = GetBuddies();
        if (allBuddies != null && allBuddies.Length > 0)
        {
     foreach (GaimBuddy buddy in allBuddies)
     {
      if (searchString == null)
      {
       try
       {
        buddies.Add(buddy);
       }
       catch {}
       continue;
      }
      string compareString = null;
      if (attributeName != null && attributeName == "Alias")
      {
       compareString = buddy.Alias;
      }
      if (compareString == null)
      {
       compareString = buddy.Name;
      }
      if (compareString != null)
      {
       compareString = compareString.ToLower();
       searchString = searchString.ToLower();
       switch(operation)
       {
        case SearchOp.Begins:
     if (compareString.StartsWith(searchString))
     {
      try
      {
       buddies.Add(buddy);
      }
      catch {}
     }
     break;
        case SearchOp.Exists:
        case SearchOp.Contains:
        default:
     if (compareString.IndexOf(searchString) >= 0)
     {
      try
      {
       buddies.Add(buddy);
      }
      catch {}
     }
     break;
       }
      }
     }
        }
        else
        {
     return (GaimBuddy[])buddies.ToArray(typeof(Simias.Gaim.GaimBuddy));
        }
        try
        {
     buddies.Sort(BuddyComparer.GetInstance());
        }
        catch{}
        return (GaimBuddy[])buddies.ToArray(typeof(Simias.Gaim.GaimBuddy));
 }
Example #10
0
 /// <summary>
 /// Performs a raw, unfiltered search at the SPI level,
 /// eliminating duplicates from the result set.
 /// </summary>
 /// <param name="search">The search SPI</param>
 /// <param name="oclass">The object class - passed through to
 /// connector so it may be null if the connecor
 /// allowing it to be null. (This is convenient for
 /// unit tests, but will not be the case in general)</param>
 /// <param name="filter">The filter to search on</param>
 /// <param name="options">The options - may be null - will
 /// be cast to an empty OperationOptions</param>
 /// <returns>The list of results.</returns>
 public static IList <ConnectorObject> SearchToList <T>(SearchOp <T> search,
                                                        ObjectClass oclass,
                                                        Filter filter) where T : class
 {
     return(SearchToList(search, oclass, filter, null));
 }
Example #11
0
 /// <summary>
 /// Starts a search for a specific set of domain members.
 /// </summary>
 /// <param name="domainID">The identifier of the domain to search for members in.</param>
 /// <param name="attributeName">Name of attribute to search.</param>
 /// <param name="searchString">String that contains a pattern to search for.</param>
 /// <param name="operation">Type of search operation to perform.</param>
 /// <param name="count">Maximum number of member objects to return.</param>
 /// <param name="searchContext">Receives a provider specific search context object. This object must be serializable.</param>
 /// <param name="memberList">Receives an array object that contains the domain Member objects.</param>
 /// <param name="total">Receives the total number of objects found in the search.</param>
 /// <returns>True if there are more domain members. Otherwise false is returned.</returns>
 public bool FindFirstDomainMembers(string domainID, string attributeName, string searchString, SearchOp operation, int count, out string searchContext, out Member[] memberList, out int total)
 {
     searchContext = null;
     memberList    = null;
     total         = 0;
     return(false);
 }
 public bool FindFirstDomainMembers( string domainID, string attributeName, string searchString, SearchOp operation, int count, out string searchContext, out Member[] memberList, out int total )
 {
     ArrayList members = new ArrayList();
        ArrayList allMembers = new ArrayList();
        searchContext = null;
        total = 0;
        GaimBuddy[] buddies =
     GaimDomain.SearchForBuddies(mapSimiasAttribToGaim(attributeName),
        searchString,
        operation);
        if (buddies != null && buddies.Length > 0)
        {
     total = buddies.Length;
     foreach (GaimBuddy buddy in buddies)
     {
      string[] machineNames = buddy.MachineNames;
      for (int i = 0; i < machineNames.Length; i++)
      {
       Member member = GaimDomain.FindBuddyInDomain(buddy, machineNames[i]);
       if (member == null)
       {
        member = new Member(buddy.GetSimiasMemberName(machineNames[i]),
     buddy.GetSimiasUserID(machineNames[i]),
     Simias.Storage.Access.Rights.ReadWrite,
     null, null);
        string alias = buddy.Alias;
        if (alias != null)
        {
     member.FN = string.Format("{0} ({1})", alias, machineNames[i]);
        }
       }
       if (members.Count < count)
       {
        members.Add(member);
       }
       allMembers.Add(member);
      }
     }
        }
        memberList = members.ToArray(typeof(Member)) as Member[];
        if (allMembers.Count > 0)
        {
     GaimDomainSearchContext newSearchContext = new GaimDomainSearchContext();
     newSearchContext.Members = allMembers;
     newSearchContext.CurrentIndex = members.Count;
     searchContext = newSearchContext.ID;
     lock (searchContexts.SyncRoot)
     {
      searchContexts.Add(searchContext, newSearchContext);
     }
        }
        return members.Count < allMembers.Count ? true : false;
 }
Example #13
0
        void Search(SearchOp op, SearchBy by, object criteria)
        {
            List <GameObject> query = new List <GameObject>();

            var all = FindAllSceneObjects();

            switch (by)
            {
            case SearchBy.Name:
                foreach (var go in all)
                {
                    if (go.name.Contains((string)criteria))
                    {
                        query.Add(go);
                    }
                }
                break;

            case SearchBy.Tag:
                query.AddRange(GameObject.FindGameObjectsWithTag((string)criteria));
                break;

            case SearchBy.Layer:
                foreach (var go in all)
                {
                    if (go.layer == LayerMask.NameToLayer((string)criteria))
                    {
                        query.Add(go);
                    }
                }
                break;

            case SearchBy.ComponentType:
                if (s_assemblyTypes.ContainsKey((string)criteria))
                {
                    Type t = s_assemblyTypes[(string)criteria];
                    if (typeof(Component).IsAssignableFrom(t))
                    {
                        Component[] components = (Component[])Resources.FindObjectsOfTypeAll(t);
                        if (components != null)
                        {
                            foreach (var c in components)
                            {
                                if (c.gameObject.scene != null && !query.Contains(c.gameObject))
                                {
                                    query.Add(c.gameObject);
                                }
                            }
                        }
                    }
                }
                break;

            case SearchBy.Mesh:
                Mesh mesh = (Mesh)criteria;
                foreach (var go in all)
                {
                    MeshFilter filter = go.GetComponent <MeshFilter>();
                    if (filter != null && filter.sharedMesh == mesh)
                    {
                        query.Add(go);
                    }
                }
                break;

            case SearchBy.Material:
                Material mat = (Material)criteria;
                foreach (var go in all)
                {
                    Renderer renderer = go.GetComponent <Renderer>();
                    if (renderer != null)
                    {
                        if (renderer.sharedMaterials.Contains(mat))
                        {
                            query.Add(go);
                        }
                    }
                }
                break;
            }

            switch (op)
            {
            case SearchOp.Find:
                searchResults = query;
                break;

            case SearchOp.Add:
                foreach (var item in query)
                {
                    if (!searchResults.Contains(item))
                    {
                        searchResults.Add(item);
                    }
                }
                break;

            case SearchOp.Refine:
                List <GameObject> refined = new List <GameObject>();
                foreach (var item in searchResults)
                {
                    if (query.Contains(item))
                    {
                        refined.Add(item);
                    }
                }
                searchResults = refined;
                break;
            }
        }
Example #14
0
 /// <summary>
 /// Construct a Query that can be used to perform a global query.
 /// </summary>
 /// <param name="property"></param>
 /// <param name="op"></param>
 /// <param name="value"></param>
 /// <param name="type"></param>
 public Query(string property, SearchOp op, string value, Syntax type) :
     this(null, property, op, value, type)
 {
 }
Example #15
0
        /// <summary>
        /// Starts a search for a specific set of domain members.
        /// </summary>
        /// <param name="domainID">The identifier of the domain to search for members in.</param>
        /// <param name="attributeName">Attribute name to search.</param>
        /// <param name="searchString">String that contains a pattern to search for.</param>
        /// <param name="operation">Type of search operation to perform.</param>
        /// <param name="count">Maximum number of member objects to return.</param>
        /// <param name="searchContext">Receives a provider specific search context object.</param>
        /// <param name="memberList">Receives an array object that contains the domain Member objects.</param>
        /// <param name="total">Receives the total number of objects found in the search.</param>
        /// <returns>True if there are more domain members. Otherwise false is returned.</returns>
        static public bool FindFirstDomainMembers(string domainID, string attributeName, string searchString, SearchOp operation, int count, out string searchContext, out Member[] memberList, out int total)
        {
            bool moreEntries = false;

            // Initialize the outputs.
            searchContext = null;
            memberList    = null;
            total         = 0;

            IDomainProvider idp = GetDomainProvider(domainID);

            if (idp != null)
            {
                moreEntries = idp.FindFirstDomainMembers(domainID, attributeName, searchString, operation, count, out searchContext, out memberList, out total);
            }

            return(moreEntries);
        }
Example #16
0
        /// <summary>
        /// Starts a search for a specific set of domain members.
        /// </summary>
        /// <param name="domainID">The identifier of the domain to search for members in.</param>
        /// <param name="attributeName">Name of attribute to search.</param>
        /// <param name="searchString">String that contains a pattern to search for.</param>
        /// <param name="operation">Type of search operation to perform.</param>
        /// <param name="count">Maximum number of member objects to return.</param>
        /// <param name="searchContext">Receives a provider specific search context object. This object must be serializable.</param>
        /// <param name="memberList">Receives an array object that contains the domain Member objects.</param>
        /// <param name="total">Receives the total number of objects found in the search.</param>
        /// <returns>True if there are more domain members. Otherwise false is returned.</returns>
        public bool FindFirstDomainMembers(string domainID, string attributeName, string searchString, SearchOp operation, int count, out string searchContext, out Member[] memberList, out int total)
        {
            bool moreEntries = false;

            // Initialize the outputs.
            searchContext = null;
            memberList    = null;
            total         = 0;

            // Start the search for the specific members of the domain.
            Domain domain = store.GetDomain(domainID);

            if (domain != null)
            {
                ICSList     list        = domain.Search(attributeName, searchString, operation);
                SearchState searchState = new SearchState(domainID, list.GetEnumerator() as ICSEnumerator, list.Count);
                searchContext = searchState.ContextHandle;
                total         = list.Count;
                moreEntries   = FindNextDomainMembers(ref searchContext, count, out memberList);
            }

            return(moreEntries);
        }
Example #17
0
    public static void GetOrphanediFolders( )
    {
        Store.Initialize(SimiasDataPath, true, -1);
        Store store = Store.GetStore();

        if (store == null)
        {
            Console.WriteLine("store could not be initialized.....");
        }
        Domain domain = store.GetDomain(store.DefaultDomain);

        SearchOp searchOperation = SearchOp.Begins;
        string   pattern         = "*";

        CatalogEntry[] catalogEntries;
        string         OrphanedOwnerProperty = "OrphOwnerDN";
        string         MemberProperty        = "mid";
        int            max      = 0;
        int            index    = 0;
        string         accessID = null;

        Console.WriteLine();
        Console.WriteLine("**************************ORPHAN IfOLDER REPORT********************* ");
        Console.WriteLine();
        try
        {
            Simias.Storage.SearchPropertyList SearchPrpList = new Simias.Storage.SearchPropertyList();
            ArrayList list  = new ArrayList();
            int       i     = 0;
            int       total = 0;
            SearchPrpList.Add(OrphanedOwnerProperty, "*", SearchOp.Exists);
            SearchPrpList.Add(BaseSchema.ObjectName, pattern, searchOperation);
            if (accessID != null)
            {
                SearchPrpList.Add(MemberProperty, accessID, SearchOp.Begins);
            }
            ICSList searchList = Catalog.Search(SearchPrpList);

            total = searchList.Count;
            SearchState searchState = new SearchState(domain.ID, searchList.GetEnumerator() as ICSEnumerator, searchList.Count);
            if (index != 0)
            {
                searchState.Enumerator.SetCursor(Simias.Storage.Provider.IndexOrigin.SET, index);
            }
            foreach (ShallowNode sn in searchList)
            {
                if (max != 0 && i++ >= max)
                {
                    break;
                }
                CatalogEntry catEntry      = Catalog.ConvertToCataloEntry(sn);
                DateTime     lastModified  = (DateTime)catEntry.Properties.GetSingleProperty("LastModified").Value;
                string       PreviousOwner = catEntry.Properties.GetSingleProperty(OrphanedOwnerProperty).Value as string;
                Console.WriteLine("iFolder Name :{0}, iFolder ID:{1}, PreviousOwner:{2}, Orphaned on:{3}", catEntry.Name, catEntry.CollectionID, PreviousOwner, lastModified);
                //list.Add(new iFolder(Catalog.ConvertToCataloEntry(sn), accessID));
            }
        }
        catch (Exception ee)
        {
        }
        finally
        {
            Store.DeleteInstance();
        }
    }