public void RunSimpleListThreaded()
		{
			int NUMBER_OF_ITERATIONS = 1000;
			int NUMBER_OF_THREADS_PER_OP = 10;
			int NUMBER_OF_STARTING_ITEMS = NUMBER_OF_ITERATIONS * NUMBER_OF_THREADS_PER_OP;

			//Change the below object from SafeList to
			//NonSafeList to see the test fail.
			ISimpleList list = new SafeList();

			//Prefill the list so that we KNOW that after all additions and removals
			//there will be the original number of items still in the list.
			//This is because doing a Remove on an empty list will not reduce the count.
			for (int i = 0; i < NUMBER_OF_STARTING_ITEMS; i++)
			{
				list.Add(new Object());
			}

			List<Thread> threads = new List<Thread>();

			for (int k = 0; k < NUMBER_OF_THREADS_PER_OP; k++)
			{
				threads.Add(new Thread(delegate()
					{
						Thread.Sleep(10); //Allow time for other threads to start
						for (int i = 0; i < NUMBER_OF_ITERATIONS; i++)
						{
							list.Add(new object());
						}
					})
				);
			}

			for (int k = 0; k < 10; k++)
			{
				threads.Add(new Thread(delegate()
					{
						Thread.Sleep(10); //Allow time for other threads to start
						for (int i = 0; i < NUMBER_OF_ITERATIONS; i++)
						{
							list.Remove();
						}
					})
				);
			}

			//Start all the threads
			foreach (Thread t in threads)
			{
				t.Start();
			}

			//Wait for them all to end
			foreach (Thread t in threads)
			{
				t.Join();
			}

			Assert.AreEqual(list.Count, NUMBER_OF_STARTING_ITEMS);
		}
        private static string eliminateParameterizedTypes(string s)
        {
            // find all occurrences of [...] and eliminate
            var res   = (string)s.Clone();
            var stack = new SafeList <int>();

            stack.Add(res.IndexOf("[", 0));
            while (stack.Count > 0)
            {
                var topIndex = stack[stack.Count - 1];
                if (topIndex == -1)
                {
                    break;
                }
                var nextLeft  = res.IndexOf("[", topIndex + 1);
                var nextRight = res.IndexOf("]", topIndex + 1);
                if (nextLeft != -1 && nextLeft < nextRight)
                {
                    stack.Add(nextLeft);
                    continue;
                }
                res = res.Remove(topIndex, nextRight - topIndex + 1);
                stack.RemoveAt(stack.Count - 1);
                if (stack.Count == 0 && topIndex < res.Length)
                {
                    stack.Add(res.IndexOf("[", topIndex));
                }
            }
            return(res);
        }
Ejemplo n.º 3
0
 private void ConnectClientWithNewSession(NetworkConnection networkConnection)
 {
     Logger.RegistrationLog("Client  (" + networkConnection.RemoteEndPoint.ToString() + ") wants to connect ");
     networkConnection.ClientSession = new Session(SessionIDGenerator.GetID());
     Logger.RegistrationLog("Assigned Session " + networkConnection.ClientSession.SessionID + " to Client " + networkConnection.RemoteEndPoint.ToString());
     SendSessionResponse(networkConnection);
     ConnectionsReadyForQueingUpToMatchmaking.Add(networkConnection);
     AcceptedConnections.Remove(networkConnection);
 }
        public override GuiWidget AddChild(GuiWidget childToAdd, int indexInChildrenList = -1)
        {
            if (childToAdd is IWrapChildrenSeparatly)
            {
                foreach (var child in childToAdd.Children)
                {
                    addedChildren.Add(child);
                }
            }
            else
            {
                addedChildren.Add(childToAdd);
            }

            return(childToAdd);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Creates a thread.
        /// </summary>
        /// <returns>ThreadId</returns>
        public int CreateThread()
        {
            int threadId;

            if (!this.DestroyedExecutionMonitorIds.TryDequeue(out threadId))
            {
                threadId = this.ThreadExecutionMonitors.Count;
                this.ThreadExecutionMonitors.Add(null);
            }

            SafeDebug.Assert(this.ThreadExecutionMonitors[threadId] == null,
                             "this.destroyedExecutionMonitorIds[threadId] == null");

            SafeList <IThreadExecutionMonitor> childExecutionMonitors =
                new SafeList <IThreadExecutionMonitor>(2); // all callbacks

            foreach (var monitorFactory in this.MonitorFactories)
            {
                IThreadExecutionMonitor monitor;
                if (monitorFactory.TryCreateThreadMonitor(threadId, out monitor))
                {
                    childExecutionMonitors.Add(monitor);
                }
            }

            this.ThreadExecutionMonitors[threadId] =
                new ThreadExecutionMonitorMultiplexer(childExecutionMonitors);

            return(threadId);
        }
Ejemplo n.º 6
0
        public void Set <T>(ICacheItem <T> item)
        {
            var serializedItem = new SerializedCacheItem <T>(item);

            _cache.Set(item.Key, serializedItem, DateTimeOffset.FromFileTime(item.ExpirationTime.ToFileTime()));
            _keys.Add(item.Key);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Creates new channel with custom event handler, authenticator and options
        /// </summary>
        /// <exception cref="OperationCanceledException">Thrown when channel limit is exceeded for the server</exception>
        /// <exception cref="DuplicateNameException">Thrown when there is already a channel with same name</exception>
        public Channel CreateChannel(string name,
                                     IChannelAuthenticator authenticator,
                                     IChannelEventHandler eventHandler,
                                     IMessageDeliveryHandler deliveryHandler,
                                     ChannelOptions options)
        {
            if (Options.ChannelLimit > 0 && _channels.Count >= Options.ChannelLimit)
            {
                throw new OperationCanceledException("Channel limit is exceeded for the server");
            }

            Channel channel = _channels.Find(x => x.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));

            if (channel != null)
            {
                throw new DuplicateNameException("There is already a channel with same name: " + name);
            }

            channel = new Channel(this, options, name, authenticator, eventHandler, deliveryHandler);
            _channels.Add(channel);

            if (eventHandler != null)
            {
                _ = eventHandler.OnChannelCreated(channel);
            }

            return(channel);
        }
Ejemplo n.º 8
0
        public void SynchronizedListFact()
        {
            var list = new SafeList <string>();

            void AddElements()
            {
                Enumerable.Range(0, Iterations)
                .ToList()
                .ForEach(i => list.Add(i.ToString()));
            }

            var threads = new List <Thread>()
            {
                new Thread(AddElements)
                {
                    Name = "1"
                },
                new Thread(AddElements)
                {
                    Name = "2"
                },
                new Thread(AddElements)
                {
                    Name = "3"
                },
                new Thread(AddElements)
                {
                    Name = "4"
                }
            };

            threads.ForEach(t => t.Start());
            threads.ForEach(t => t.Join());
            Assert.Equal(Iterations * 4, list.Count());
        }
Ejemplo n.º 9
0
        //#####################################################################################
        // 작업 쓰레드용 함수

        protected void AcceptThreadJob()
        {
            while (m_acceptRun)
            {
                // 보류중인 접속이 없으면 대기
                while (!m_listener.Pending())
                {
                    if (m_acceptRun == false)
                    {
                        return;
                    }

                    Thread.Sleep(128);
                }

                // 접속확인
                Socket newClient = m_listener.AcceptSocket();

                // 클라이언트 객체 생성
                if (newClient != null)
                {
                    ServerVisitor client = new ServerVisitor(newClient);

                    m_clientList.Add(client);


                    // 이벤트 발생
                    WhenConnected(client);
                }
            }
        }
Ejemplo n.º 10
0
        public void updateNewAbilities()
        {
            return;

            newAbilities.Clear();

            foreach (Ability ability in abilities.Values)
            {
                if (ability.MinLevel == this.digLevel_)
                {
                    newAbilities.Add(ability);
                }
            }

            if (abilities.Count == 1)
            {
                this.player.Reply("You can now " + abilities.First().Value.AbilityText + "! :P");
            }
            else if (abilities.Count > 1)
            {
                string abilityText = "";
                string lastAbility = "";
                foreach (Ability ability in abilities.Values)
                {
                    abilityText += lastAbility + ", ";
                    lastAbility  = ability.AbilityText;
                }
                abilityText = abilityText.Substring(abilityText.Length - 2);

                // TODO: Split long texts!...
                this.player.Reply("You can now " + abilityText + " and " + lastAbility + "! :O");
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// If type is an interface, returns all concrete implementing classes
        /// else if type is an abstract class, returns all concrete extending classes
        /// </summary>
        /// <param name="psd"></param>
        /// <param name="type"></param>
        /// <param name="extendingClasses"></param>
        /// <returns></returns>
        public static bool TryGetExtendingClasses(PexMeStaticDatabase psd, TypeEx type, out IIndexable <TypeDefinition> extendingClasses)
        {
            //load inheritance hierarchies if not already done
            psd.LoadInheritanceHierarchies();
            extendingClasses = null;

            TypeStore ts;

            if (!psd.TypeDictionary.TryGetValue(type.Definition, out ts))
            {
                return(false);
            }

            SafeSet <TypeDefinition> extendingClassesSet = new SafeSet <TypeDefinition>();

            CollectAllExtendingClasses(ts, extendingClassesSet);

            if (extendingClassesSet.Count == 0)
            {
                return(false);
            }

            var extendingClassesList = new SafeList <TypeDefinition>();

            foreach (var tdef in extendingClassesSet)
            {
                extendingClassesList.Add(tdef);
            }

            extendingClasses = extendingClassesList;
            return(true);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Adds the client to the queue
        /// </summary>
        public async Task <QueueSubscriptionResult> AddClient(MqClient client)
        {
            foreach (IQueueAuthenticator authenticator in Server.QueueAuthenticators)
            {
                bool allowed = await authenticator.Authenticate(this, client);

                if (!allowed)
                {
                    return(QueueSubscriptionResult.Unauthorized);
                }
            }

            if (Options.ClientLimit > 0 && _clients.Count >= Options.ClientLimit)
            {
                return(QueueSubscriptionResult.Full);
            }

            QueueClient cc = new QueueClient(this, client);

            _clients.Add(cc);
            client.AddSubscription(cc);

            foreach (IQueueEventHandler handler in Server.QueueEventHandlers)
            {
                await handler.OnConsumerSubscribed(cc);
            }

            _ = Trigger();
            OnConsumerSubscribed.Trigger(cc);
            return(QueueSubscriptionResult.Success);
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Add an entity to the scene.
 /// </summary>
 public T Add <T>(T entity) where T : Entity
 {
     entity.Scene = this;
     Entities.Add(entity);
     entity.Initialize();
     return(entity);
 }
Ejemplo n.º 14
0
        /// <summary>
        ///Add 的测试
        ///</summary>
        public void AddTestHelper <ValueT>()
        {
            SafeList <ValueT> target = new SafeList <ValueT>(); // TODO: 初始化为适当的值
            ValueT            value  = default(ValueT);         // TODO: 初始化为适当的值

            target.Add(value);
            Assert.Inconclusive("无法验证不返回值的方法。");
        }
Ejemplo n.º 15
0
        public void 繞行SafeList操作集合_不同執行緒同時對SafeList新增與刪除元素_不應擲出例外()
        {
            var safeList = new SafeList <int> {
                1, 2, 3, 4, 5
            };

            Task.Run(() =>
            {
                while (true)
                {
                    safeList.Add(0);
                }
            });

            Task.Run(() =>
            {
                while (true)
                {
                    safeList.Remove(0);
                }
            });

            Task.Run(() =>
            {
                while (true)
                {
                    var result = safeList.FindAll(x => x < 1);
                }
            });

            Task.Run(() =>
            {
                while (true)
                {
                    safeList.AddRange(Enumerable.Range(0, 3));
                }
            });

            Task.Run(() =>
            {
                while (true)
                {
                    safeList.RemoveAll(x => x < 1);
                }
            });

            Task.Run(() =>
            {
                while (true)
                {
                    safeList.Clear();
                }
            });

            Action action = () => IterateList(safeList).Wait();

            action.Should().NotThrow();
        }
Ejemplo n.º 16
0
 public void AddedElementIncludedInIteration()
 {
     IterateTrigger(
         list,
         "two",
         () => list.Add("new"),
         "zero", "one", "two", "three", "four", "new"
         );
 }
Ejemplo n.º 17
0
 private void StartGamesExecutionThreads()
 {
     Logger.LoadBalancerLog("Starting Games Executors according to Threadcount of CPU");
     for (int id = 0; id < LogicalCoreCount; id++)
     {
         GamesExecutors.Add(new GamesExecutor(id, FrameWaitConditions[id % (int)CPULoadBalanceFactor]));
         ThreadStarter.ThreadpoolDebug("Games Executor Thread " + id.ToString(), GamesExecutors[id].Run);
     }
 }
Ejemplo n.º 18
0
        private void OnSocketAccept(object sender, Socket acceptedSocket)
        {
            Logger.RegistrationLog("Client connected " + acceptedSocket.RemoteEndPoint.ToString());
            TCPPacketConnection tcp = new TCPPacketConnection(acceptedSocket);
            NetworkConnection   newNetworkConnection = new NetworkConnection(tcp);

            Logger.ServerLog("Adding Client to Accepted Connections");
            AcceptedConnections.Add(newNetworkConnection);
        }
Ejemplo n.º 19
0
 private static void AddToCulpritField(IEnumerable <Field> accessedFields, SafeList <Field> culpritFields)
 {
     foreach (var acfield in accessedFields)
     {
         if (PexMeFilter.IsTypeSupported(acfield.Type))
         {
             culpritFields.Add(acfield);
         }
     }
 }
Ejemplo n.º 20
0
 /// <summary>
 /// アカウントを登録します。
 /// </summary>
 /// <param name="accountInfo">登録するアカウント情報</param>
 public static void RegisterAccount(AccountInfo accountInfo)
 {
     if (accountInfo == null)
     {
         throw new ArgumentNullException("accountInfo");
     }
     accounts.Add(accountInfo);
     OnAccountsChanged(EventArgs.Empty);
     // アカウント情報のキャッシュ
     // Task.Factory.StartNew(() => accountInfo.UserViewModel);
 }
Ejemplo n.º 21
0
 public bool AddGame(Game game)
 {
     if (StopExecutor)
     {
         return(false);
     }
     else
     {
         Games.Add(game);
         return(true);
     }
 }
Ejemplo n.º 22
0
        private void CreateFireball()
        {
            var mp          = InputManager.MousePosition.ToVector2();
            var spawnCircle = new Circle(_wizard.Position, ProjectileCircleRadius);
            var pos         = spawnCircle.Sample();
            var dir         = mp - pos;

            dir.Normalize();
            var fb = new Fireball(pos, dir * 200f);

            Projectiles.Add(fb);
        }
Ejemplo n.º 23
0
        public void 初始化一個SafeList並加入1個元素_加入成功_集合中應包含該元素且長度為1()
        {
            var safeList = new SafeList <int>();
            var fixture  = new Fixture();
            var element  = fixture.Create <int>();

            safeList.Add(element);
            const int expecetedCount = 1;

            safeList[0].Should().Be(element);
            safeList.Count.Should().Be(expecetedCount);
        }
Ejemplo n.º 24
0
        public override void Load()
        {
            var oemParts = StaticData.Instance.GetFiles(Path.Combine("OEMSettings", "SampleParts"));

            Items = new SafeList <ILibraryItem>(oemParts.Select(s => new StaticDataItem(s)));

            Items.Add(new GeneratorItem(
                          () => "Set Temperature".Localize(),
                          async() => await SetTemperatureObject3D.Create())
            {
                Category = this.Name
            });

            Items.Add(new GeneratorItem(
                          () => "PLA Temperature Tower".Localize(),
                          async() => await TemperatureTowerObject3D.Create(220))
            {
                Category = this.Name
            });
            Items.Add(new GeneratorItem(
                          () => "ABS Temperature Tower".Localize(),
                          async() => await TemperatureTowerObject3D.Create(250))
            {
                Category = this.Name
            });
            Items.Add(new GeneratorItem(
                          () => "PETG Temperature Tower".Localize(),
                          async() => await TemperatureTowerObject3D.Create(260))
            {
                Category = this.Name
            });
#if DEBUG
            Items.Add(new GeneratorItem(
                          () => "XY Calibration".Localize(),
                          async() => await XyCalibrationFaceObject3D.Create())
            {
                Category = this.Name
            });
#endif
        }
Ejemplo n.º 25
0
 public void AddClientToQueue(NetworkConnection clientConnection, ClientInitializeGamePackage initData)
 {
     if (Matchmaking.AddRequestToQueue(clientConnection.ClientSession.SessionID, initData.GamePlayerCount, initData.PlayerTeamwish))
     {
         m_waitingClientConnections.Add(clientConnection);
         SendMatchmakingStatus(clientConnection, string.Format(WAITING_IN_QUEUE, TotalPlayersOnlineCallback(), TotalPlayersSearching()));
         clientConnection.ConnectionDiedEvent += RemoveConnection;
     }
     else
     {
         SendMatchmakingError(clientConnection, INVALID_REQUEST);
     }
 }
Ejemplo n.º 26
0
        private static void Accepter_ClientConnected(object sender, Socket acceptedSocket)
        {
            TCPPacketConnection connection = new TCPPacketConnection(acceptedSocket);

            connection.Logger = logger;
            _connections.Add(connection);
            connection.InitializeCrypto(new RSACrypto(false));

            //DualConnection connection = new DualConnection(acceptedSocket, IPAddress.Any);
            //connection.Logger = logger;
            //_connections.Add(connection);
            //connection.Initialize(false);
        }
Ejemplo n.º 27
0
        /// <summary>
        /// Creates new Router and adds it to server routers.
        /// Throws exception if name is not eligible
        /// </summary>
        public IRouter AddRouter(string name, RouteMethod method)
        {
            try
            {
                if (!Filter.CheckNameEligibility(name))
                {
                    throw new InvalidOperationException("Invalid router name");
                }

                if (_routers.Find(x => x.Name == name) != null)
                {
                    throw new DuplicateNameException();
                }

                Router router = new Router(this, name, method);
                _routers.Add(router);
                return(router);
            }
            catch (Exception e)
            {
                SendError("ADD_ROUTER", e, $"RouterName:{name}");
                throw;
            }
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Creates new queue in the channel
        /// </summary>
        /// <exception cref="NoNullAllowedException">Thrown when server does not have default delivery handler implementation</exception>
        /// <exception cref="OperationCanceledException">Thrown when queue limit is exceeded for the channel</exception>
        /// <exception cref="DuplicateNameException">Thrown when there is already a queue with same id</exception>
        public async Task <ChannelQueue> CreateQueue(ushort queueId,
                                                     ChannelQueueOptions options,
                                                     IMessageDeliveryHandler deliveryHandler)
        {
            if (deliveryHandler == null)
            {
                throw new NoNullAllowedException("Delivery handler cannot be null.");
            }

            //multiple queues are not allowed
            if (!Options.AllowMultipleQueues && _queues.Count > 0)
            {
                return(null);
            }

            //if content type is not allowed for this channel, return null
            if (Options.AllowedQueues != null && Options.AllowedQueues.Length > 0)
            {
                if (!Options.AllowedQueues.Contains(queueId))
                {
                    return(null);
                }
            }

            if (Options.QueueLimit > 0 && Options.QueueLimit >= _queues.Count)
            {
                throw new OperationCanceledException("Queue limit is exceeded for the channel");
            }

            ChannelQueue queue = _queues.Find(x => x.Id == queueId);

            if (queue != null)
            {
                throw new DuplicateNameException($"The channel has already a queue with same content type: {queueId}");
            }

            queue = new ChannelQueue(this, queueId, options, deliveryHandler);
            _queues.Add(queue);

            if (EventHandler != null)
            {
                await EventHandler.OnQueueCreated(queue, this);
            }

            return(queue);
        }
Ejemplo n.º 29
0
        public void OnMatchmadeGameFound(object sender, MatchmakingManager.MatchData match)
        {
            GameNetwork newGameNetwork = new GameNetwork(MasterUDPSocket, Logger, SessionManager);
            Game        newGame        = new Game(newGameNetwork, match.MaxPlayerCount, GamesIDGenerator);

            foreach (MatchmakingManager.ClientData client in match.Clients)
            {
                if (!newGame.AddClient(client.m_clientConnection, client.m_request.GetPlayerPlacements()))
                {
                    Logger.GamesManagerLog("The client couldn't be added to the game, either the matchmaking algorithm is flawed or the AddClient Method");
                    Logger.GamesManagerLog("The client consists of the following placement request" + client.m_request.GetPlayerPlacements().ToString());
                    Logger.GamesManagerLog("The game object looks like this: " + newGame.ToString());
                    throw new System.Exception("The client couldn't be added to the game, either the matchmaking algorithm is flawed or the AddClient Method");
                }
            }

            GamesReadyToBeStarted.Add(newGame);
        }
Ejemplo n.º 30
0
        public override void Update(GameTime gameTime)
        {
            if (InputManager.KeyPressed(Keys.Space))
            {
                Enemies.Add(new EnemyKnight());
            }

            if (InputManager.MousePressed())
            {
                CreateFireball();
            }

            base.Update(gameTime);

            foreach (var projectile in Projectiles)
            {
                projectile.Update(gameTime);

                // brute-force this for now
                foreach (var enemy in Enemies)
                {
                    if (enemy.Bounding.Overlaps(projectile.Bounding))
                    {
                        projectile.Hit(enemy);
                    }
                }

                if (projectile.Destroyed)
                {
                    Projectiles.Remove(projectile);
                }
            }
            foreach (var enemy in Enemies)
            {
                enemy.Update(gameTime);
                if (enemy.Dead)
                {
                    Enemies.Remove(enemy);
                }
            }

            Projectiles.Commit();
            Enemies.Commit();
        }
Ejemplo n.º 31
0
        /// <summary>
        /// Creates a thread.
        /// </summary>
        /// <returns>ThreadId</returns>
        public int CreateThread()
        {
            int threadId;
            if (!this.DestroyedExecutionMonitorIds.TryDequeue(out threadId))
            {
                threadId = this.ThreadExecutionMonitors.Count;
                this.ThreadExecutionMonitors.Add(null);
            }

            SafeDebug.Assert(this.ThreadExecutionMonitors[threadId] == null,
                "this.destroyedExecutionMonitorIds[threadId] == null");

            SafeList<IThreadExecutionMonitor> childExecutionMonitors =
                new SafeList<IThreadExecutionMonitor>(2); // all callbacks

            foreach (var monitorFactory in this.MonitorFactories)
            {
                IThreadExecutionMonitor monitor;
                if (monitorFactory.TryCreateThreadMonitor(threadId, out monitor))
                {
                    childExecutionMonitors.Add(monitor);
                }
            }

            this.ThreadExecutionMonitors[threadId] =
                new ThreadExecutionMonitorMultiplexer(childExecutionMonitors);

            return threadId;
        }
Ejemplo n.º 32
0
        private void PurgeUsedRegions(bool forcePurge, SafeList<Canvas> invalidatedResources)
        {
            for(var item = _UsedRegions.First; item != null; item = item.Next)
            {
                if(!item.Value.CanvasReference.IsAlive || forcePurge)
                {
                    if(forcePurge)
                    {
                        var context = (Canvas.ResolvedContext)item.Value.CanvasReference.Target;

                        if(context != null)
                        {
                            context.BackingContext = null;

                            invalidatedResources.Add(context.Target);
                        }
                    }

                    Rectangle region = item.Value.ActualRegion;

                    _UsedRegions.Remove(item);

                    _FragmentedArea += region.Area;
                }
            }
        }
Ejemplo n.º 33
0
        /// <summary>
        /// If type is an interface, returns all concrete implementing classes
        /// else if type is an abstract class, returns all concrete extending classes
        /// </summary>
        /// <param name="psd"></param>
        /// <param name="type"></param>
        /// <param name="extendingClasses"></param>
        /// <returns></returns>
        public static bool TryGetExtendingClasses(PexMeStaticDatabase psd, TypeEx type, out IIndexable<TypeDefinition> extendingClasses)
        {
            //load inheritance hierarchies if not already done
            psd.LoadInheritanceHierarchies();
            extendingClasses = null;

            TypeStore ts;
            if (!psd.TypeDictionary.TryGetValue(type.Definition, out ts))
                return false;

            SafeSet<TypeDefinition> extendingClassesSet = new SafeSet<TypeDefinition>();
            CollectAllExtendingClasses(ts, extendingClassesSet);

            if (extendingClassesSet.Count == 0)
                return false;

            var extendingClassesList = new SafeList<TypeDefinition>();
            foreach (var tdef in extendingClassesSet)
            {
                extendingClassesList.Add(tdef);
            }

            extendingClasses = extendingClassesList;
            return true;
        }
Ejemplo n.º 34
0
 private static void AddToCulpritField(IEnumerable<Field> accessedFields, SafeList<Field> culpritFields)
 {
     foreach (var acfield in accessedFields)
     {
         if (PexMeFilter.IsTypeSupported(acfield.Type))
         {
             culpritFields.Add(acfield);
         }
     }
 }
Ejemplo n.º 35
0
        /// <summary>
        /// Propagates the changes made by a called method to its caller, based on the lastLoadedFields        
        /// For example, if the called method modifies any fields, then the related parent fields in the caller method
        /// are marked as updated
        /// </summary>
        /// <param name="callerMStore"></param>
        /// <param name="calledMethodStore"></param>
        private void PropagateModificationsToCaller(SEMethodStore callerMStore, SEMethodStore calledMethodStore, Method calledMethod)
        {
            if (this.lastLoadedFields.Count == 0)
                return;

            //Idenitfy relevant fields from the last loadedFields
            SafeList<Field> fieldsProcessed = new SafeList<Field>();
            Field receiverField = null;

            //Check whether the current method call is actually on the field previously loaded
            TypeEx methodDeclType;
            if (!calledMethod.TryGetDeclaringType(out methodDeclType))
            {
                logger.Error("Failed to get the declaring type of the method: " + calledMethod.FullName);
                return;
            }

            if (methodDeclType.FullName == "System.String" || methodDeclType.FullName == "System.string")
            {
                return; //Do not process string types.
            }

            //Check whether the declaring type is in the fields list
            foreach (var field in this.lastLoadedFields)
            {
                var fieldType = field.Type;
                if (fieldType == methodDeclType || fieldType.IsAssignableTo(methodDeclType) || methodDeclType.IsAssignableTo(fieldType))
                {
                    fieldsProcessed.Add(field);
                    receiverField = field;
                    break;
                }
            }

            if (receiverField == null)
            {
                //Failed to identify the reciver field of this method
                return;
            }

            //Identify arguments of the current method call
            foreach (var argtype in calledMethod.ParameterTypes)
            {
                foreach (var field in this.lastLoadedFields)
                {
                    if (field == receiverField)
                        continue;

                    var fieldType = field.Type;
                    if (fieldType == argtype || fieldType.IsAssignableTo(argtype) || argtype.IsAssignableTo(fieldType))
                    {
                        fieldsProcessed.Add(field);
                        break;
                    }
                }
            }

            if (calledMethodStore.DefinedFieldSet.Count == 0)
            {
                //If the called method does not define any field, all current fields are just loaded fields
                foreach (var field in fieldsProcessed)
                {
                    callerMStore.AddToUsedList(field, this.currOffset);
                    this.lastLoadedFields.Remove(field);
                }
            }
            else
            {
                //process each defined field
                foreach (var deffield in calledMethodStore.DefinedFieldSet.Values)
                {
                    TypeEx deffieldType;
                    if (deffield.OptionalField.TryGetDeclaringType(out deffieldType))
                    {
                        //Identify the related field in the lastLoadedFields
                        Field processedField = null;
                        foreach (var field in fieldsProcessed)
                        {
                            var fieldType = field.Type;
                            if (fieldType == deffieldType || fieldType.IsAssignableTo(deffieldType) || deffieldType.IsAssignableTo(fieldType))
                            {
                                processedField = field;
                                callerMStore.AddToDefinedList(field, this.currOffset);
                                break;
                            }
                        }

                        if (processedField != null)
                        {
                            fieldsProcessed.Remove(processedField);
                            this.lastLoadedFields.Remove(processedField);
                        }
                    }
                }

                //Consider the remaining fields at usedfields and remove them from lastLoadedFields
                foreach (var field in fieldsProcessed)
                {
                    callerMStore.AddToUsedList(field, this.currOffset);
                    this.lastLoadedFields.Remove(field);
                }
            }
        }
Ejemplo n.º 36
0
        public void Purge(bool isForced, SafeList<Canvas> invalidatedResources)
        {
            if(isForced)
            {
                var context = (Canvas.ResolvedContext)_CanvasContext.Target;

                if(context != null)
                {
                    context.BackingContext = null;

                    invalidatedResources.Add(context.Target);
                }

                _CanvasContext.Target = null;
            }
            else if(!_CanvasContext.IsAlive)
            {
                _CanvasContext.Target = null;
            }
        }