示例#1
0
文件: ResourceList.cs 项目: mo5h/omeo
        public void IndexedSort(int propID)
        {
            lock (this)
            {
                if (_list == null)
                {
                    Instantiate();
                }

                IntHashSet hashSet = new IntHashSet();
                for (int i = 0; i < _list.Count; i++)
                {
                    hashSet.Add(_list [i]);
                }
                int        destIndex = 0;
                IResultSet rs        = MyPalStorage.Storage.SelectResourcesWithProp(propID);
                foreach (IRecord rec in rs)
                {
                    int id = rec.GetIntValue(0);
                    if (hashSet.Contains(id))
                    {
                        _list [destIndex++] = id;
                    }
                }
            }
        }
示例#2
0
        public void InsertAndDeletePageBenchmark()
        {
            IntHashSet numbers = new IntHashSet();
            const int queueSize = 4000;
            TestKey keyFactory = new TestKey();
            IBTree bTree = new /*BTree*/OmniaMeaBTree( _indexFileName, keyFactory );
            using( bTree )
            {
                bTree.Open( );

                Queue queue = new Queue( queueSize );
                for ( int i = 0; i < queueSize; i++ )
                {
                    TestKey testKey = new TestKey( GetUniqueRand( numbers ) );
                    queue.Enqueue( testKey );
                    bTree.InsertKey( testKey, (int)testKey.Key );
                }
                int time = System.Environment.TickCount;
                for ( int i = 0; i < 100000; i++ )
                {
                    TestKey testKey = (TestKey)queue.Dequeue();
                    bTree.DeleteKey( testKey, (int)testKey.Key );
                    numbers.Remove( (int)testKey.Key );
                    TestKey newKey = new TestKey( GetUniqueRand( numbers ) );
                    queue.Enqueue( newKey );
                    bTree.InsertKey( newKey, (int)newKey.Key );
                }
                time = System.Environment.TickCount - time;
                Console.WriteLine( " work took " + time.ToString() );

                bTree.Close();
            }
        }
示例#3
0
 static public int constructor(IntPtr l)
 {
     try {
         int        argc = LuaDLL.lua_gettop(l);
         IntHashSet o;
         if (argc == 1)
         {
             o = new IntHashSet();
             pushValue(l, true);
             pushValue(l, o);
             return(2);
         }
         else if (argc == 2)
         {
             System.Collections.Generic.IEnumerable <System.Int32> a1;
             checkType(l, 2, out a1);
             o = new IntHashSet(a1);
             pushValue(l, true);
             pushValue(l, o);
             return(2);
         }
         return(error(l, "New object failed."));
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#4
0
        public override void EnumerationFinished()
        {
            if (_db != null)
            {
                _db.Close();
            }

            if (_updatedConversations != null)
            {
                foreach (IntHashSet.Entry e in _updatedConversations)
                {
                    IResource res = Core.ResourceStore.TryLoadResource(e.Key);
                    if (res != null)
                    {
                        Core.FilterEngine.ExecRules(StandardEvents.ResourceReceived, res);
                        Core.TextIndexManager.QueryIndexing(res.Id);
                    }
                }
                _updatedConversations = null;
            }

            long endTicks = DateTime.Now.Ticks;

            Trace.WriteLineIf(IniSettings.TraceImport,
                              "Miranda import took " + (endTicks - _startTicks) / 10000 + " ms");

            if (!Interrupted && _indexStartDate == DateTime.MinValue)
            {
                IniSettings.FullIndexingCompleted = true;
                ExecuteInIdle = false;
            }
            _completed = true;
        }
示例#5
0
        public void SearchForRangeOrderTest()
        {
            IntHashSet numbers = new IntHashSet();
            TestKey keyFactory = new TestKey();
            IBTree bTree = new /*BTree*/OmniaMeaBTree( _indexFileName, keyFactory );
            using( bTree )
            {
                bTree.Open();
                TestKey testKey = new TestKey( 0 );

                for ( int i = 0; i < 10000; i++ )
                {
                    testKey = new TestKey( GetUniqueRand( numbers ) );
                    bTree.InsertKey( testKey, (int)testKey.Key );
                }

                ArrayList keys_offsets = new ArrayList();
                bTree.SearchForRange( new TestKey( 0 ), testKey, keys_offsets );
                for( int j = 1; j < keys_offsets.Count; ++j )
                {
                    KeyPair pair1 = (KeyPair) keys_offsets[ j - 1 ];
                    KeyPair pair2 = (KeyPair) keys_offsets[ j ];
                    if( pair1._key.CompareTo( pair2._key ) > 0 )
                    {
                        throw new Exception( "Invalid key order, j = " + j );
                    }
                }

                bTree.Close();
            }
        }
示例#6
0
        /// <summary>
        /// Resturns list of handles of all available files.
        /// </summary>
        /// <returns></returns>
        public IntArrayList GetAllFiles(bool idle)
        {
            int        handle;
            IntHashSet deletedFiles = new IntHashSet();

            handle = _stream.GetFirstFreeFileHandle();
            while (IsValidHandle(handle) && Core.State != CoreState.ShuttingDown &&
                   (!idle || Core.IsSystemIdle))
            {
                deletedFiles.Add(handle);
                ClusteredCachedStream.Cluster cluster = _stream.GetCluster(handle);
                handle = _stream.OffsetToHandle(cluster.NextOffset);
            }
            IntArrayList result = new IntArrayList();

            for (long off = ClusteredCachedStream.BLOB_FILE_SYSTEM_HEADER_SIZE; off < _stream.Length;)
            {
                if (Core.State == CoreState.ShuttingDown || (idle && !Core.IsSystemIdle))
                {
                    break;
                }
                handle = _stream.OffsetToHandle(off);
                ClusteredCachedStream.Cluster cluster = _stream.GetCluster(handle);
                if (cluster.PrevOffset == ClusteredCachedStream.NOT_SET && !deletedFiles.Contains(handle))
                {
                    result.Add(handle);
                }
                off += cluster.Length;
                off += ClusteredCachedStream.CLUSTER_HEADER_SIZE;
            }
            return(result);
        }
示例#7
0
        internal virtual System.Func <int, bool> GetPropertyPermissions(ISet <string> roles, System.Func <string, int> tokenLookup)
        {
            if (_propertyAuthorization)
            {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableIntSet blackListed = new org.eclipse.collections.impl.set.mutable.primitive.IntHashSet();
                MutableIntSet blackListed = new IntHashSet();
                foreach (string role in roles)
                {
                    if (_roleToPropertyBlacklist.ContainsKey(role))
                    {
                        Debug.Assert(_roleToPropertyBlacklist[role] != null, "Blacklist has to contain properties");
                        foreach (string propName in _roleToPropertyBlacklist[role])
                        {
                            try
                            {
                                blackListed.add(tokenLookup(propName));
                            }
                            catch (Exception)
                            {
                                _securityLog.error("Error in setting up property permissions, '" + propName + "' is not a valid property name.");
                            }
                        }
                    }
                }
                return(property => !blackListed.contains(property));
            }
            else
            {
                return(property => true);
            }
        }
示例#8
0
        public void ImportDB(IMirandaDB db)
        {
            _updatedConversations = new IntHashSet();
            _db = db;

            if (_db.FileSize == _lastFileSize && _db.SlackSpace == _lastSlackSpace)
            {
                TraceImport("Skipping Miranda DB import because file size and slack space did not change");
                _contactEnumerator = null;
                return;
            }
            _lastFileSize   = _db.FileSize;
            _lastSlackSpace = db.SlackSpace;

            ImportContact(_db.UserContact, true);
            if (_selfContact == null)
            {
                _selfContact = Core.ContactManager.MySelf.Resource;
            }

            // for AIM, we cannot create the contact resource from
            // the account, so hook the contact to the account later
            foreach (IResource acct in _selfAccounts.Values)
            {
                if (!acct.HasLink(Props.MirandaAcct, _selfContact))
                {
                    acct.AddLink(Props.MirandaAcct, _selfContact);
                }
            }

            _contactIndex      = 0;
            _contactEnumerator = _db.Contacts.GetEnumerator();
        }
        private void CheckProperty(NodeRecord record, CheckerEngine <NodeRecord, Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport> engine, ICollection <PropertyRecord> props)
        {
            if (!Record.NO_NEXT_PROPERTY.@is(record.NextProp))
            {
                PropertyRecord firstProp = props.GetEnumerator().next();
                if (!Record.NO_PREVIOUS_PROPERTY.@is(firstProp.PrevProp))
                {
                    engine.Report().propertyNotFirstInChain(firstProp);
                }

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableIntSet keys = new org.eclipse.collections.impl.set.mutable.primitive.IntHashSet();
                MutableIntSet keys = new IntHashSet();
                foreach (PropertyRecord property in props)
                {
                    if (!property.InUse())
                    {
                        engine.Report().propertyNotInUse(property);
                    }
                    else
                    {
                        foreach (int key in ChainCheck.keys(property))
                        {
                            if (!keys.add(key))
                            {
                                engine.Report().propertyKeyNotUniqueInChain();
                            }
                        }
                    }
                }
            }
        }
示例#10
0
        private static void  CollectResources(string resType, IntHashSet result, IntHashSet source, int level)
        {
            IntHashSet temp = new IntHashSet();

            foreach (IntHashSet.Entry e in source)
            {
                IResourceList children = Core.ResourceStore.LoadResource(e.Key).GetLinksTo(resType, Core.Props.Reply);
                for (int i = 0; i < children.Count; i++)
                {
                    int chid = children[i].Id;
                    if (!source.Contains(chid) && !result.Contains(chid))
                    {
                        temp.Add(chid);
                    }
                }
            }

            foreach (IntHashSet.Entry e in temp)
            {
                result.Add(e.Key);
            }

            if (temp.Count > 0)
            {
                CollectResources(resType, result, temp, level + 1);
            }
        }
示例#11
0
        private void ScanEverythingBelongingToRelationships(RelationshipMappings relMappings)
        {
            using (RelationshipScanCursor relationshipScanCursor = _cursors.allocateRelationshipScanCursor(), PropertyCursor propertyCursor = _cursors.allocatePropertyCursor())
            {
                _dataRead.allRelationshipsScan(relationshipScanCursor);
                while (relationshipScanCursor.Next())
                {
                    int typeId = relationshipScanCursor.Type();
                    relationshipScanCursor.Properties(propertyCursor);
                    MutableIntSet propertyIds = IntSets.mutable.empty();

                    while (propertyCursor.Next())
                    {
                        int propertyKey = propertyCursor.PropertyKey();

                        Value           currentValue = propertyCursor.PropertyValue();
                        Pair <int, int> key          = Pair.of(typeId, propertyKey);
                        UpdateValueTypeInMapping(currentValue, key, relMappings.RelationshipTypeIdANDPropertyTypeIdToValueType);

                        propertyIds.add(propertyKey);
                    }
                    propertyCursor.Close();

                    MutableIntSet oldPropertyKeySet = relMappings.RelationshipTypeIdToPropertyKeys.getOrDefault(typeId, _emptyPropertyIdSet);

                    // find out which old properties we did not visited and mark them as nullable
                    if (oldPropertyKeySet == _emptyPropertyIdSet)
                    {
                        if (propertyIds.size() == 0)
                        {
                            // Even if we find property key on other rels with this type, set all of them nullable
                            relMappings.NullableRelationshipTypes.Add(typeId);
                        }

                        propertyIds.addAll(oldPropertyKeySet);
                    }
                    else
                    {
                        MutableIntSet currentPropertyIdsHelperSet = new IntHashSet(propertyIds.size());
                        currentPropertyIdsHelperSet.addAll(propertyIds);
                        propertyIds.removeAll(oldPropertyKeySet);                                     // only the brand new ones in propIds now
                        oldPropertyKeySet.removeAll(currentPropertyIdsHelperSet);                     // only the old ones that are not on the new rel

                        propertyIds.addAll(oldPropertyKeySet);
                        propertyIds.forEach(id =>
                        {
                            Pair <int, int> key = Pair.of(typeId, id);
                            relMappings.RelationshipTypeIdANDPropertyTypeIdToValueType[key].setNullable();
                        });

                        propertyIds.addAll(currentPropertyIdsHelperSet);
                    }

                    relMappings.RelationshipTypeIdToPropertyKeys[typeId] = propertyIds;
                }
                relationshipScanCursor.Close();
            }
        }
示例#12
0
        private void ScanEverythingBelongingToNodes(NodeMappings nodeMappings)
        {
            using (NodeCursor nodeCursor = _cursors.allocateNodeCursor(), PropertyCursor propertyCursor = _cursors.allocatePropertyCursor())
            {
                _dataRead.allNodesScan(nodeCursor);
                while (nodeCursor.Next())
                {
                    // each node
                    SortedLabels labels = SortedLabels.From(nodeCursor.Labels());
                    nodeCursor.Properties(propertyCursor);
                    MutableIntSet propertyIds = IntSets.mutable.empty();

                    while (propertyCursor.Next())
                    {
                        Value currentValue           = propertyCursor.PropertyValue();
                        int   propertyKeyId          = propertyCursor.PropertyKey();
                        Pair <SortedLabels, int> key = Pair.of(labels, propertyKeyId);
                        UpdateValueTypeInMapping(currentValue, key, nodeMappings.LabelSetANDNodePropertyKeyIdToValueType);

                        propertyIds.add(propertyKeyId);
                    }
                    propertyCursor.Close();

                    MutableIntSet oldPropertyKeySet = nodeMappings.LabelSetToPropertyKeys.getOrDefault(labels, _emptyPropertyIdSet);

                    // find out which old properties we did not visited and mark them as nullable
                    if (oldPropertyKeySet == _emptyPropertyIdSet)
                    {
                        if (propertyIds.size() == 0)
                        {
                            // Even if we find property key on other nodes with those labels, set all of them nullable
                            nodeMappings.NullableLabelSets.Add(labels);
                        }

                        propertyIds.addAll(oldPropertyKeySet);
                    }
                    else
                    {
                        MutableIntSet currentPropertyIdsHelperSet = new IntHashSet(propertyIds.size());
                        currentPropertyIdsHelperSet.addAll(propertyIds);
                        propertyIds.removeAll(oldPropertyKeySet);                                     // only the brand new ones in propIds now
                        oldPropertyKeySet.removeAll(currentPropertyIdsHelperSet);                     // only the old ones that are not on the new node

                        propertyIds.addAll(oldPropertyKeySet);
                        propertyIds.forEach(id =>
                        {
                            Pair <SortedLabels, int> key = Pair.of(labels, id);
                            nodeMappings.LabelSetANDNodePropertyKeyIdToValueType[key].setNullable();
                        });

                        propertyIds.addAll(currentPropertyIdsHelperSet);
                    }

                    nodeMappings.LabelSetToPropertyKeys[labels] = propertyIds;
                }
                nodeCursor.Close();
            }
        }
示例#13
0
        public void AddResources(IResourceList resources)
        {
            IResourceIdCollection ids = resources.ResourceIds;

            _ids = new IntHashSet(ids.Count / 2);
            foreach (int id in ids)
            {
                _ids.Add(id);
            }
        }
示例#14
0
文件: OperaProfile.cs 项目: mo5h/omeo
 private void CollectAllSubNodes(IResource root, IntHashSet nodes)
 {
     if (root != _root)
     {
         nodes.Add(root.Id);
     }
     foreach (IResource child in BookmarkService.SubNodes(null, root))
     {
         CollectAllSubNodes(child, nodes);
     }
 }
示例#15
0
        public virtual IntSet Types(int startingFromType, int upToType)
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableIntSet set = new org.eclipse.collections.impl.set.mutable.primitive.IntHashSet((upToType - startingFromType) * 2);
            MutableIntSet set = new IntHashSet((upToType - startingFromType) * 2);

            for (int i = startingFromType; i < upToType; i++)
            {
                set.add(Get(i).TypeId);
            }
            return(set);
        }
示例#16
0
 static public int Clear(IntPtr l)
 {
     try {
         IntHashSet self = (IntHashSet)checkSelf(l);
         self.Clear();
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#17
0
 static public int get_Comparer(IntPtr l)
 {
     try {
         IntHashSet self = (IntHashSet)checkSelf(l);
         pushValue(l, true);
         pushValue(l, self.Comparer);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#18
0
 protected static int GetUniqueRand( IntHashSet numbers )
 {
     /*int rand = _random.Next( );
     while ( numbers.Contains( rand ) )
     {
         rand = _random.Next( );
     }
     numbers.Add( rand );
     return rand;**/
     numbers.Add( ++_i );
     return _i;
 }
示例#19
0
        public void SequentialSearchDeleteInsert()
        {
            IntHashSet numbers = new IntHashSet();
            const int queueSize = 100000;
            TestKey keyFactory = new TestKey();
            IBTree bTree = new /*BTree*/OmniaMeaBTree( _indexFileName, keyFactory );
            using( bTree )
            {
                bTree.Open( );

                //Random random = new Random( System.Environment.TickCount );
                Queue queue = new Queue( queueSize );
                for ( int i = 0; i < queueSize; i++ )
                {
                    int key = GetUniqueRand( numbers );
                    TestKey testKey = new TestKey( key );
                    queue.Enqueue( testKey );
                    bTree.InsertKey( testKey, key );
                }
                bTree.Close();
                if( !bTree.Open() )
                {
                    throw new Exception( "Can't reopen btree! ");
                }
                int time = System.Environment.TickCount;
                IntArrayList offsets = new IntArrayList();
                for ( int i = 0; i < 20000; i++ )
                {
                    TestKey testKey = (TestKey)queue.Dequeue();
                    offsets.Clear();
                    bTree.SearchForRange( testKey, testKey, offsets );
                    Assert.AreEqual( 1, offsets.Count, testKey.Key.ToString() + " not found. i = " + i.ToString() );
                    Assert.AreEqual( (int)testKey.Key, offsets[0] );
                    bTree.DeleteKey( testKey, (int)testKey.Key );
                    numbers.Remove( (int)testKey.Key );
                    offsets.Clear();
                    bTree.SearchForRange( testKey, testKey, offsets );
                    Assert.AreEqual( 0, offsets.Count );
                    TestKey newKey = new TestKey( GetUniqueRand( numbers ) );
                    queue.Enqueue( newKey );
                    bTree.InsertKey( newKey, (int)newKey.Key );
                    offsets.Clear();
                    bTree.SearchForRange( newKey, newKey, offsets );
                    Assert.AreEqual( 1, offsets.Count );
                    Assert.AreEqual( (int)newKey.Key, offsets[0] );
                }
                time = System.Environment.TickCount - time;
                Console.WriteLine( " work took " + time.ToString() );

                bTree.Close();
            }
        }
示例#20
0
 static public int UnionWith(IntPtr l)
 {
     try {
         IntHashSet self = (IntHashSet)checkSelf(l);
         System.Collections.Generic.IEnumerable <System.Int32> a1;
         checkType(l, 2, out a1);
         self.UnionWith(a1);
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#21
0
 static public int OnDeserialization(IntPtr l)
 {
     try {
         IntHashSet    self = (IntHashSet)checkSelf(l);
         System.Object a1;
         checkType(l, 2, out a1);
         self.OnDeserialization(a1);
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#22
0
        private void DoStressProcessing( IBTree bTree )
        {
            const int initialSize = 500000;
            const int iterations = 1000000;

            IntHashSet uniqueKeys = new IntHashSet();
            IntArrayList array = new IntArrayList();
            using( bTree )
            {
                bTree.Open();
                for( int i = 0; i < initialSize; ++i )
                {
                    bTree.InsertKey( new TestKey( GetUniqueRand( uniqueKeys ) ), 0 );
                }

                for( int i = 0; i < iterations; ++i )
                {
                    int key = 0;
                    foreach( IntHashSet.Entry e in uniqueKeys )
                    {
                        key = e.Key;
                        break;
                    }
                    array.Clear();
                    bTree.SearchForRange( new TestKey( key ), new TestKey( key ), array );
                    Assert.AreEqual( 1, array.Count );
                    bTree.DeleteKey( new TestKey( key ), 0 );
                    uniqueKeys.Remove( key );
                    if( ( i & 31 ) == 5 )
                    {
                        array.Clear();
                        bTree.GetAllKeys( array );
                        Assert.AreEqual( initialSize + i - 1, array.Count );
                        Assert.AreEqual( uniqueKeys.Count, array.Count );
                    }
                    bTree.InsertKey( new TestKey( GetUniqueRand( uniqueKeys ) ), 0 );
                    bTree.InsertKey( new TestKey( GetUniqueRand( uniqueKeys ) ), 0 );
                    if( ( i & 31 ) == 17 )
                    {
                        array.Clear();
                        bTree.GetAllKeys( array );
                        Assert.AreEqual( initialSize + i + 1, array.Count );
                        Assert.AreEqual( uniqueKeys.Count, array.Count );
                    }
                    Trace.WriteLine( "Passes: " + i );
                }
                bTree.Close();
            }
        }
示例#23
0
 static public int RemoveWhere(IntPtr l)
 {
     try {
         IntHashSet self = (IntHashSet)checkSelf(l);
         System.Predicate <System.Int32> a1;
         LuaDelegation.checkDelegate(l, 2, out a1);
         var ret = self.RemoveWhere(a1);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#24
0
 static public int IsProperSupersetOf(IntPtr l)
 {
     try {
         IntHashSet self = (IntHashSet)checkSelf(l);
         System.Collections.Generic.IEnumerable <System.Int32> a1;
         checkType(l, 2, out a1);
         var ret = self.IsProperSupersetOf(a1);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#25
0
 static public int Remove(IntPtr l)
 {
     try {
         IntHashSet   self = (IntHashSet)checkSelf(l);
         System.Int32 a1;
         checkType(l, 2, out a1);
         var ret = self.Remove(a1);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#26
0
 static public int GetObjectData(IntPtr l)
 {
     try {
         IntHashSet self = (IntHashSet)checkSelf(l);
         System.Runtime.Serialization.SerializationInfo a1;
         checkType(l, 2, out a1);
         System.Runtime.Serialization.StreamingContext a2;
         checkValueType(l, 3, out a2);
         self.GetObjectData(a1, a2);
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
示例#27
0
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public System.Func<org.neo4j.kernel.impl.store.record.RelationshipRecord,Check<org.neo4j.kernel.impl.store.record.RelationshipRecord,org.neo4j.consistency.report.ConsistencyReport_RelationshipConsistencyReport>> forRelationships(final org.neo4j.consistency.report.ConsistencyReporter reporter)
        public virtual System.Func <RelationshipRecord, Check <RelationshipRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipConsistencyReport> > ForRelationships(ConsistencyReporter reporter)
        {
            return(relationship =>
            {
                int[] propertyKeys = _relationships.get(relationship.Type);
                if (propertyKeys != null)
                {
                    MutableIntSet keys = new IntHashSet(propertyKeys.Length);
                    foreach (int key in propertyKeys)
                    {
                        keys.add(key);
                    }
                    return new RealCheck <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord, Check <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipConsistencyReport> >(relationship, typeof(ConsistencyReport.RelationshipConsistencyReport), reporter, RecordType.Relationship, keys);
                }
                return NoCheck();
            });
        }
示例#28
0
文件: TasksPlugin.cs 项目: mo5h/omeo
        /// <summary>
        /// Called to return the drop effect when the specified data object is dragged over the
        /// specified resource.
        /// </summary>
        /// <param name="targetResource">The resource over which the drag happens.</param>
        /// <param name="data">The <see cref="IDataObject"/> containing the dragged data.</param>
        /// <param name="allowedEffect">The drag-and-drop operations which are allowed by the
        /// originator (or source) of the drag event.</param>
        /// <param name="keyState">The current state of the SHIFT, CTRL, and ALT keys,
        /// as well as the state of the mouse buttons.</param>
        /// <returns>The target drop effect.</returns>
        public DragDropEffects DragOver(IResource targetResource, IDataObject data, DragDropEffects allowedEffect, int keyState)
        {
            if (data.GetDataPresent(typeof(IResourceList)))            // Dragging resources over
            {
                // The resources we're dragging
                IResourceList dragResources = (IResourceList)data.GetData(typeof(IResourceList));

                // Restrict the allowed target res-types
                if (!((targetResource.Type == "Task") || (targetResource == Core.ResourceTreeManager.GetRootForType("Task"))))
                {
                    return(DragDropEffects.None);
                }

                // Collect all the direct and indirect parents of the droptarget; then we'll check to avoid dropping parent on its children
                IntHashSet ancestors = new IntHashSet();
                IResource  parent    = targetResource;
                while (parent != null)
                {
                    ancestors.Add(parent.Id);
                    parent = parent.GetLinkProp(TasksPlugin._linkSuperTask);
                }

                // Measure some metrics on the dragged resources, don't allow mixing tasks/resources and prohibit the internal resources
                bool bAllTasks   = true;
                bool bNoTasks    = true;
                bool bNoInternal = true;
                foreach (IResource res in dragResources)
                {
                    bAllTasks   = bAllTasks && (res.Type == "Task");
                    bNoTasks    = bNoTasks && (res.Type != "Task");
                    bNoInternal = bNoInternal && (!Core.ResourceStore.ResourceTypes[res.Type].HasFlag(ResourceTypeFlags.Internal));
                    if (ancestors.Contains(res.Id))
                    {
                        return(DragDropEffects.None);                           // Dropping parent on a child
                    }
                }
                if (((!bAllTasks) && (!bNoTasks)) || (!bNoInternal))
                {
                    return(DragDropEffects.None);
                }

                // Link attachments, move the tasks
                return(bAllTasks ? DragDropEffects.Move : DragDropEffects.Link);
            }
            return(DragDropEffects.None);
        }
示例#29
0
文件: JetTextBox.cs 项目: mo5h/omeo
        static JetTextBox()
        {
            // Keys that should not be fed to the action processor
            _hashEditorKeys = new IntHashSet();

            lock (_hashEditorKeys)
            {
                _hashEditorKeys.Add((int)Keys.Delete);
                _hashEditorKeys.Add((int)Keys.Back);
                _hashEditorKeys.Add((int)Keys.Space);
                _hashEditorKeys.Add((int)Keys.Left);
                _hashEditorKeys.Add((int)Keys.Right);
                _hashEditorKeys.Add((int)Keys.Up);
                _hashEditorKeys.Add((int)Keys.Down);
                _hashEditorKeys.Add((int)(Keys.Back | Keys.Control));
                _hashEditorKeys.Add((int)(Keys.Delete | Keys.Control));
            }
        }
示例#30
0
        private void CreateMissingTokens(string[] names, int[] ids)
        {
            lock (this)
            {
                // We redo the resolving under the lock, to make sure that these ids are really missing, and won't be
                // created concurrently with us.
                MutableIntSet unresolvedIndexes = new IntHashSet();
                ResolveIds(names, ids, i => !unresolvedIndexes.add(i));
                if (!unresolvedIndexes.Empty)
                {
                    // We still have unresolved ids to create.
                    ObjectIntHashMap <string> createdTokens     = CreateUnresolvedTokens(unresolvedIndexes, names, ids);
                    IList <NamedToken>        createdTokensList = new List <NamedToken>(createdTokens.size());
                    createdTokens.forEachKeyValue((name, index) => createdTokensList.Add(new NamedToken(name, ids[index])));

                    TokenRegistry.putAll(createdTokensList);
                }
            }
        }