示例#1
10
        public User(StateManager stateMgr, API.Geo.World world)
        {
            this.mStateMgr = stateMgr;
            this.mWorld = world;
            this.mTimeSinceGUIOpen = new Timer();

            this.mCameraMan = null;
            this.IsAllowedToMoveCam = true;
            this.IsFreeCamMode = true;
            Camera cam = this.mStateMgr.Camera;
            cam.Position = new Vector3(-203, 633, -183);
            cam.Orientation = new Quaternion(0.3977548f, -0.1096644f, -0.8781486f, -0.2421133f);
            this.mCameraMan = new CameraMan(cam);
            this.mSelectedAllies = new HashSet<VanillaNonPlayer>();
            this.mRandom = new Random();

            this.mFigures = new MOIS.KeyCode[10];
            for (int i = 0; i < 9; i++)
                this.mFigures[i] = (MOIS.KeyCode)System.Enum.Parse(typeof(MOIS.KeyCode), "KC_" + (i + 1));
            this.mFigures[9] = MOIS.KeyCode.KC_0;

            this.mWireCube = this.mStateMgr.SceneMgr.RootSceneNode.CreateChildSceneNode();
            this.mWireCube.AttachObject(StaticRectangle.CreateRectangle(this.mStateMgr.SceneMgr, Vector3.UNIT_SCALE * Cst.CUBE_SIDE));
            this.mWireCube.SetVisible(false);

            this.Inventory = new Inventory(10, 4, new int[] { 3, 0, 1, 2 }, true);
        }
        private void AssignConnectors(DialogueEntry entry, Conversation conversation, HashSet<string> alreadyConnected, HashSet<int> entriesVisited, int level)
        {
            // Sanity check to prevent infinite recursion:
            if (level > 10000) return;

            // Set non-connectors:
            foreach (Link link in entry.outgoingLinks) {
                if (link.originConversationID == link.destinationConversationID) {
                    string destination = string.Format("{0}.{1}", link.destinationConversationID, link.destinationDialogueID);
                    if (alreadyConnected.Contains(destination)) {
                        link.isConnector = true;
                    } else {
                        link.isConnector = false;
                        alreadyConnected.Add(destination);
                    }
                }
            }

            // Then process each child:
            foreach (Link link in entry.outgoingLinks) {
                if (link.originConversationID == link.destinationConversationID) {
                    if (!entriesVisited.Contains(link.destinationDialogueID)) {
                        entriesVisited.Add(link.destinationDialogueID);
                        var childEntry = conversation.GetDialogueEntry(link.destinationDialogueID);
                        if (childEntry != null) {
                            AssignConnectors(childEntry, conversation, alreadyConnected, entriesVisited, level + 1);
                        }
                    }
                }
            }
        }
        private static void SwapParameterTypes(MethodDefinition method,
            TypeDefinition targetDependency,
            TypeReference interfaceType,
            HashSet<MethodReference> modifiedMethods)
        {
            if (method.IsAbstract || !method.HasBody)
                return;

            bool modified = false;
            var parameters = method.Parameters.Cast<ParameterDefinition>();
            foreach (var parameter in parameters)
            {
                var parameterType = parameter.ParameterType;
                if (parameterType != targetDependency)
                    continue;

                parameter.ParameterType = interfaceType;
                modified = true;
            }

            if (!modified)
                return;

            modifiedMethods.Add(method);
        }
            internal AnalysisQueue(VsProjectAnalyzer analyzer) {
                _workEvent = new AutoResetEvent(false);
                _cancel = new CancellationTokenSource();
                _analyzer = analyzer;

                // save the analysis once it's ready, but give us a little time to be
                // initialized and start processing stuff...
                _lastSave = DateTime.Now - _SaveAnalysisTime + TimeSpan.FromSeconds(10);

                _queue = new List<IAnalyzable>[PriorityCount];
                for (int i = 0; i < PriorityCount; i++) {
                    _queue[i] = new List<IAnalyzable>();
                }
                _enqueuedGroups = new HashSet<IGroupableAnalysisProject>();

                _workThread = new Thread(Worker);
                _workThread.Name = "Node.js Analysis Queue";
                _workThread.Priority = ThreadPriority.BelowNormal;
                _workThread.IsBackground = true;

                // start the thread, wait for our synchronization context to be created
                using (AutoResetEvent threadStarted = new AutoResetEvent(false)) {
                    _workThread.Start(threadStarted);
                    threadStarted.WaitOne();
                }
            }
示例#5
1
        public static int Solution2(Stopwatch timer)
        {
            timer.Restart();

            var a = new HashSet<int>();
            int maxlcm = 1;
            int t = 0;
            var results = new List<int>();

            for (int i = 2; i <= 20; i++)
            {
                int k = i%2 == 0 ? 1 : 2;
                for (int j = k; j < i; j+=2)
                {
                    if (gcd(i, j) == 1)
                    {
                        a.Add(2*i*(i + j));
                    }
                }
            }

            var sortedA = a.OrderBy(v => v).ToArray();

            while (maxlcm < 1000)
            {
                maxlcm = lcm(maxlcm, sortedA[t]);
                results.Add(maxlcm);
                t++;
            }

            int res = results[results.Count - 2];
            timer.Stop();
            return res;
        }
    static void Main()
    {
        InitializeWordsByChar();

        int textLinesCount = int.Parse(Console.ReadLine().ToLower());
        for (int i = 0; i < textLinesCount; i++)
        {
            GetWords(Console.ReadLine().ToLower());
        }

        int wordsCount = int.Parse(Console.ReadLine());
        for (int i = 0; i < wordsCount; i++)
        {
            string word = Console.ReadLine();
            string wordLowerCase = word.ToLower();
            HashSet<string> currentWords = new HashSet<string>();
            currentWords.UnionWith(wordsByChar[wordLowerCase[0]]);
            for (int j = 1; j < wordLowerCase.Length; j++)
            {
                currentWords.IntersectWith(wordsByChar[wordLowerCase[j]]);
            }

            Console.WriteLine("{0} -> {1}", word, currentWords.Count);
        }
    }
示例#7
1
        private void CollectEntities(int addr, Dictionary<int, Entity> list)
        {
            int num = addr;
            addr = M.ReadInt(addr + 4);
            var hashSet = new HashSet<int>();
            var queue = new Queue<int>();
            queue.Enqueue(addr);
            while (queue.Count > 0)
            {
                int nextAddr = queue.Dequeue();
                if (hashSet.Contains(nextAddr))
                    continue;

                hashSet.Add(nextAddr);
                if (M.ReadByte(nextAddr + 21) == 0 && nextAddr != num && nextAddr != 0)
                {
                    int key = M.ReadInt(nextAddr + 12);
                    if (!list.ContainsKey(key))
                    {
                        int address = M.ReadInt(nextAddr + 16);
                        var entity = base.GetObject<Entity>(address);
                        list.Add(key, entity);
                    }
                    queue.Enqueue(M.ReadInt(nextAddr));
                    queue.Enqueue(M.ReadInt(nextAddr + 8));
                }
            }
        }
示例#8
1
文件: Update.cs 项目: Zor-X-L/CKAN
        /// <summary>
        /// Locates the changes between the prior and post state of the modules..
        /// </summary>
        /// <param name="modules_prior">List of the available modules prior to the update.</param>
        /// <param name="modules_post">List of the available modules after the update.</param>
        private void PrintChanges(List<CkanModule> modules_prior, List<CkanModule> modules_post)
        {
            var prior = new HashSet<CkanModule>(modules_prior, new NameComparer());
            var post = new HashSet<CkanModule>(modules_post, new NameComparer());


            var added = new HashSet<CkanModule>(post.Except(prior, new NameComparer()));
            var removed = new HashSet<CkanModule>(prior.Except(post, new NameComparer()));


            var unchanged = post.Intersect(prior);//Default compare includes versions
            var updated = post.Except(unchanged).Except(added).Except(removed).ToList();

            // Print the changes.
            user.RaiseMessage("Found {0} new modules, {1} removed modules and {2} updated modules.", added.Count(), removed.Count(), updated.Count());

            if (added.Count > 0)
            {
                PrintModules("New modules [Name (CKAN identifier)]:", added);
            }

            if (removed.Count > 0)
            {
                PrintModules("Removed modules [Name (CKAN identifier)]:", removed);
            }

            if (updated.Count > 0)
            {
                PrintModules("Updated modules [Name (CKAN identifier)]:", updated);
            }
        }
        private bool m_useStrict; //= false;

        #endregion Fields

        #region Constructors

        protected JsActivationObject(JsActivationObject parent, JsSettings codeSettings)
        {
            m_isKnownAtCompileTime = true;
            m_useStrict = false;
            m_settings = codeSettings;

            Parent = parent;
            NameTable = new Dictionary<string, JsVariableField>();
            ChildScopes = new List<JsActivationObject>();

            // if our parent is a scope....
            if (parent != null)
            {
                // add us to the parent's list of child scopes
                parent.ChildScopes.Add(this);

                // if the parent is strict, so are we
                UseStrict = parent.UseStrict;
            }

            // create the two lists of declared items for this scope
            ScopeLookups = new HashSet<JsLookup>();
            VarDeclaredNames = new HashSet<IJsNameDeclaration>();
            LexicallyDeclaredNames = new HashSet<IJsNameDeclaration>();

            GhostedCatchParameters = new HashSet<JsParameterDeclaration>();
            GhostedFunctions = new HashSet<JsFunctionObject>();
        }
示例#10
1
		public override void OnUpdateList ()
		{
			base.OnUpdateList ();
			StackFrame frame = DebuggingService.CurrentFrame;
			
			if (frame == null || !FrameEquals (frame, lastFrame)) {
				tree.ClearExpressions ();
				lastExpressions = null;
			}
			lastFrame = frame;
			
			if (frame == null)
				return;
			
			//FIXME: tree should use the local refs rather than expressions. ATM we exclude items without names
			var expr = new HashSet<string> (frame.GetAllLocals ().Select (i => i.Name)
				.Where (n => !string.IsNullOrEmpty (n) && n != "?"));
			
			//add expressions not in tree already, remove expressions that are longer valid
			if (lastExpressions != null) {
				foreach (string rem in lastExpressions.Except (expr))
					tree.RemoveExpression (rem);
				foreach (string rem in expr.Except (lastExpressions))
					tree.AddExpression (rem);
			} else {
				tree.AddExpressions (expr);
			}
			
			lastExpressions = expr;
		}
        public void ModelMetadataProvider_UsesPredicateOnType()
        {
            // Arrange
            var type = typeof(User);

            var provider = CreateProvider();
            var context = new ModelBindingContext();

            var expected = new[] { "IsAdmin", "UserName" };

            // Act
            var metadata = provider.GetMetadataForType(type);

            // Assert
            var predicate = metadata.PropertyBindingPredicateProvider.PropertyFilter;

            var matched = new HashSet<string>();
            foreach (var property in metadata.Properties)
            {
                if (predicate(context, property.PropertyName))
                {
                    matched.Add(property.PropertyName);
                }
            }

            Assert.Equal<string>(expected, matched);
        }
示例#12
1
        public static void ApplySetPieces(World world)
        {
            var map = world.Map;
            int w = map.Width, h = map.Height;

            Random rand = new Random();
            HashSet<Rect> rects = new HashSet<Rect>();
            foreach (var dat in setPieces)
            {
                int size = dat.Item1.Size;
                int count = rand.Next(dat.Item2, dat.Item3);
                for (int i = 0; i < count; i++)
                {
                    IntPoint pt = new IntPoint();
                    Rect rect;

                    int max = 50;
                    do
                    {
                        pt.X = rand.Next(0, w);
                        pt.Y = rand.Next(0, h);
                        rect = new Rect() { x = pt.X, y = pt.Y, w = size, h = size };
                        max--;
                    } while ((Array.IndexOf(dat.Item4, map[pt.X, pt.Y].Terrain) == -1 ||
                             rects.Any(_ => Rect.Intersects(rect, _))) &&
                             max > 0);
                    if (max <= 0) continue;
                    dat.Item1.RenderSetPiece(world, pt);
                    rects.Add(rect);
                }
            }
        }
示例#13
1
        private static IEnumerable<long> Eratostenes()
        {
            const int max = 2000000;
            var primes = new List<long>();
            var crossedOff = new HashSet<long>();

            long candidate = 1;

            while (candidate < max)
            {
                candidate++;

                if (crossedOff.Contains(candidate))
                {
                    continue;
                }

                primes.Add(candidate);

                // remove multiples of candidate
                for (var i = candidate; i < max + 1; i += candidate)
                {
                    crossedOff.Add(i);
                }
            }

            return primes.ToArray();
        }
示例#14
1
 public static H3.Cell[] CalcCells2( Sphere[] mirrors, H3.Cell[] cells, Settings settings )
 {
     HashSet<Vector3D> completedCellIds = new HashSet<Vector3D>( cells.Select( c => c.ID ).ToArray() );
     List<H3.Cell> completedCells = new List<H3.Cell>( cells );
     ReflectCellsRecursive2( mirrors, cells, settings, completedCells, completedCellIds );
     return completedCells.ToArray();
 }
示例#15
1
 private IList<string> DFS(string s, HashSet<string> dict, Dictionary<string, IList<string>> map){
     IList<string> matches = new List<string>();
     if(s==""){  //Base Case
         matches.Add("");
         return matches;
     }
     
     if(map.ContainsKey(s)) //if s is already in the map, directly return its value
         return map[s];
         
     int len = s.Length;
     for(int i=1;i<s.Length+1;i++){
         string prev = s.Substring(0,i);
         if(dict.Contains(prev)){ //if prev is in the dict
             IList<string> postMatches = DFS(s.Substring(i,len-i),dict,map);
             foreach(string sentence in postMatches){
                 if(sentence=="") //if s.Substring(i,len) is empty
                     matches.Add(prev);
                 else
                     matches.Add(prev+" "+sentence);
             }
             
         }
     }
     map.Add(s, matches); //after get all matches for s, put the entry into map.
     return matches;
 }
示例#16
1
        public static void Write(TextWriter writer, IEnumerable<Dictionary<string, string>> records)
        {
            if (records == null) return; //AOT

            var allKeys = new HashSet<string>();
            var cachedRecords = new List<IDictionary<string, string>>();

            foreach (var record in records)
            {
                foreach (var key in record.Keys)
                {
                    if (!allKeys.Contains(key))
                    {
                        allKeys.Add(key);
                    }
                }
                cachedRecords.Add(record);
            }

            var headers = allKeys.OrderBy(key => key).ToList();
            if (!CsvConfig<Dictionary<string, string>>.OmitHeaders)
            {
                WriteRow(writer, headers);
            }
            foreach (var cachedRecord in cachedRecords)
            {
                var fullRecord = headers.ConvertAll(header => 
                    cachedRecord.ContainsKey(header) ? cachedRecord[header] : null);
                WriteRow(writer, fullRecord);
            }
        }
        public static IEnumerable<string> GetAllStyleSheets(string searchFrom, IEnumerable<string> allowedExtensions)
        {
            var project = ProjectHelpers.GetProject(searchFrom);
            var projectPath = project.Properties.Item("FullPath").Value.ToString();
            var projectUri = new Uri(projectPath, UriKind.Absolute);
            var fileNames = new HashSet<string>();
            var projectDir = Path.GetDirectoryName(projectPath);

            if (projectDir == null)
            {
                return new string[0];
            }

            foreach (var extension in allowedExtensions)
            {
                var matchingFiles = Directory.GetFiles(projectDir, "*" + extension, SearchOption.AllDirectories);

                foreach (var file in matchingFiles)
                {
                    var mappedFile = GetStyleSheetFileForUrl(file, project, projectUri);

                    if (mappedFile != null)
                    {
                        fileNames.Add(mappedFile);
                    }
                }
            }

            return fileNames;
        }
 internal CoordinatorScratchpad(Type elementType)
 {
     _elementType = elementType;
     _nestedCoordinatorScratchpads = new List<CoordinatorScratchpad>();
     _expressionWithErrorHandlingMap = new Dictionary<Expression, Expression>();
     _inlineDelegates = new HashSet<LambdaExpression>();
 }
示例#19
0
        public static VTable ConstructVTable(TypeDef typeDef, VTableStorage storage)
        {
            var ret = new VTable(typeDef);

            var slotDict = new Dictionary<VTableSignature, List<VTableSlot>>();

            // Partition II 12.2

            // Interfaces
            foreach (InterfaceImpl iface in typeDef.Interfaces) {
                VTable ifaceVTbl = storage.GetVTable(iface.Interface);
                if (ifaceVTbl != null)
                    ret.Inherit(ifaceVTbl, slotDict);
            }

            // Base type
            VTable baseVTbl = storage.GetVTable(typeDef.GetBaseTypeThrow());
            if (baseVTbl != null)
                ret.Inherit(baseVTbl, slotDict);

            List<MethodDef> virtualMethods = typeDef.Methods.Where(method => method.IsVirtual).ToList();
            var methodsProcessed = new HashSet<MethodDef>();

            // MethodImpls (Partition II 22.27)
            foreach (MethodDef method in virtualMethods)
                foreach (MethodOverride impl in method.Overrides) {
                    Debug.Assert(impl.MethodBody == method);

                    MethodDef targetMethod = impl.MethodDeclaration.ResolveThrow();
                    VTableSignature sig = VTableSignature.FromMethod(impl.MethodDeclaration);
                    Debug.Assert(slotDict.ContainsKey(sig));

                    var methodSlot = new VTableSlot(ret, method, method.DeclaringType.ToTypeSig(), VTableSignature.FromMethod(method));
                    ret.Override(slotDict, sig, methodSlot, targetMethod);
                    methodsProcessed.Add(method);
                }

            // Normal override
            foreach (MethodDef method in virtualMethods) {
                VTableSignature sig = VTableSignature.FromMethod(method);
                var methodSlot = new VTableSlot(ret, method, method.DeclaringType.ToTypeSig(), sig);
                if (slotDict.ContainsKey(sig) && slotDict[sig].Count > 0) {
                    ret.Override(slotDict, sig, methodSlot);
                    methodsProcessed.Add(method);
                }
            }

            // Remaining methods
            foreach (MethodDef method in typeDef.Methods.Where(method => method.IsVirtual).Except(methodsProcessed)) {
                var slot = new VTableSlot(ret, method, method.DeclaringType.ToTypeSig(), VTableSignature.FromMethod(method));
                if (method.IsFinal)
                    ret.Finals.Add(slot);
                else {
                    Debug.Assert(!ret.Slots.Any(s => s.MethodDef == method));
                    ret.Slots.Add(slot);
                }
            }

            return ret;
        }
示例#20
0
 public Project() {
     Configuration = new ClientConfiguration();
     NotificationSettings = new Dictionary<string, NotificationSettings>();
     PromotedTabs = new HashSet<string>();
     DeleteBotDataEnabled = true;
     Data = new DataDictionary();
 }
        public Conversion ClassifyConversionFromExpression(TypeSymbol source, TypeSymbol destination, ref HashSet<DiagnosticInfo> useSiteDiagnostics)
        {
            Debug.Assert((object)source != null);
            Debug.Assert((object)destination != null);

            return ClassifyConversionFromExpression(null, source, destination, ref useSiteDiagnostics);
        }
        // admin deletearea x y z radius
        public override bool HandleCommand(ulong userId, string[] words)
        {
            HashSet<IMyEntity> entities = new HashSet<IMyEntity>();
            HashSet<IMyEntity> entitiesToConfirm = new HashSet<IMyEntity>();
            HashSet<IMyEntity> entitiesConnected = new HashSet<IMyEntity>();
            HashSet<IMyEntity> entitiesFound = new HashSet<IMyEntity>();
            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities, x => x is IMyCubeGrid);
            });

            foreach (IMyEntity entity in entities)
            {
                if (!(entity is IMyCubeGrid))
                    continue;

                IMyCubeGrid grid = (IMyCubeGrid)entity;
                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);
                if (gridBuilder == null)
                    continue;

                bool found = false;
                foreach (MyObjectBuilder_CubeBlock block in gridBuilder.CubeBlocks)
                {
                    if (block.TypeId == typeof(MyObjectBuilder_Beacon))
                    {
                        found = true;
                        break;
                    }
                }

                if (!found)
                    entitiesToConfirm.Add(grid);
            }

            CubeGrids.GetGridsUnconnected(entitiesFound, entitiesToConfirm);

            foreach (IMyEntity entity in entitiesFound)
            {
                CubeGridEntity gridEntity = (CubeGridEntity)GameEntityManager.GetEntity(entity.EntityId);
                if (gridEntity == null)
                {
                    Log.Info("A found entity gridEntity was null!");
                    continue;
                }
                Communication.SendPrivateInformation(userId, string.Format("Found entity '{0}' ({1}) at {2} with no beacon.", gridEntity.Name, entity.EntityId, General.Vector3DToString(entity.GetPosition())));
            }

            for(int r = entitiesFound.Count - 1; r >= 0; r--)
            {
                //MyAPIGateway.Entities.RemoveEntity(entity);
                IMyEntity entity = entitiesFound.ElementAt(r);
                CubeGridEntity gridEntity = new CubeGridEntity((MyObjectBuilder_CubeGrid)entity.GetObjectBuilder(), entity);
                gridEntity.Dispose();
            }

            Communication.SendPrivateInformation(userId, string.Format("Removed {0} grids with no beacons", entitiesFound.Count));

            return true;
        }
示例#23
0
		public static string GenerateText(TypeDeclaration type, OrderedPartCollection<AbstractDynamicCompilationExtension> extensions)
		{
			var unit = new CompilationUnit();

			var namespaces = new HashSet<string>
			{
				typeof (SystemTime).Namespace,
				typeof (AbstractViewGenerator).Namespace,
				typeof (Enumerable).Namespace,
				typeof (IEnumerable<>).Namespace,
				typeof (IEnumerable).Namespace,
				typeof (int).Namespace,
				typeof (LinqOnDynamic).Namespace,
				typeof(Field).Namespace,
			};
			foreach (var extension in extensions)
			{
				foreach (var ns in extension.Value.GetNamespacesToImport())
				{
					namespaces.Add(ns);
				}
			}

			foreach (var ns in namespaces)
			{
				unit.AddChild(new Using(ns));
			}

			unit.AddChild(type);
			var output = new CSharpOutputVisitor();
			unit.AcceptVisitor(output, null);

			return output.Text;
		}
示例#24
0
 public Node(string name, FileAttributes attrs)
 {
     Attributes = attrs;
     Name = name;
     Parents = new HashSet<Node>();
     Contains = new HashSet<Node>();
 }
 private void CreateRandomIndexes(int maxSegments)
 {
     dir = NewDirectory();
     numDocs = AtLeast(150);
     int numTerms = TestUtil.NextInt(Random(), 1, numDocs / 5);
     ISet<string> randomTerms = new HashSet<string>();
     while (randomTerms.size() < numTerms)
     {
         randomTerms.add(TestUtil.RandomSimpleString(Random()));
     }
     terms = new List<string>(randomTerms);
     int seed = Random().Next();
     IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(new Random(seed)));
     iwc.SetMergePolicy(TestSortingMergePolicy.NewSortingMergePolicy(sort));
     iw = new RandomIndexWriter(new Random(seed), dir, iwc);
     for (int i = 0; i < numDocs; ++i)
     {
         Document doc = RandomDocument();
         iw.AddDocument(doc);
         if (i == numDocs / 2 || (i != numDocs - 1 && Random().nextInt(8) == 0))
         {
             iw.Commit();
         }
         if (Random().nextInt(15) == 0)
         {
             string term = RandomInts.RandomFrom(Random(), terms);
             iw.DeleteDocuments(new Term("s", term));
         }
     }
     reader = iw.Reader;
 }
示例#26
0
        /// <remarks>
        /// http://stackoverflow.com/questions/730268/unique-random-string-generation
        /// </remarks>
        string GenerateRandomString(int length,
            string allowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
        {
            if (length < 0) throw new ArgumentOutOfRangeException(nameof(length), "length cannot be less than zero.");
            if (string.IsNullOrEmpty(allowedChars)) throw new ArgumentException("allowedChars may not be empty.");

            const int byteSize = 0x100;
            var allowedCharSet = new HashSet<char>(allowedChars).ToArray();
            if (byteSize < allowedCharSet.Length)
                throw new ArgumentException($"allowedChars may contain no more than {byteSize} characters.");

            // Guid.NewGuid and System.Random are not particularly random. By using a
            // cryptographically-secure random number generator, the caller is always
            // protected, regardless of use.
            using (var rng = new System.Security.Cryptography.RNGCryptoServiceProvider())
            {
                var result = new StringBuilder();
                var buf = new byte[128];
                while (result.Length < length)
                {
                    rng.GetBytes(buf);
                    for (var i = 0; i < buf.Length && result.Length < length; ++i)
                    {
                        // Divide the byte into allowedCharSet-sized groups. If the
                        // random value falls into the last group and the last group is
                        // too small to choose from the entire allowedCharSet, ignore
                        // the value in order to avoid biasing the result.
                        var outOfRangeStart = byteSize - (byteSize%allowedCharSet.Length);
                        if (outOfRangeStart <= buf[i]) continue;
                        result.Append(allowedCharSet[buf[i]%allowedCharSet.Length]);
                    }
                }
                return result.ToString();
            }
        }
示例#27
0
        /// <summary>
        /// Add Hundreds of Stock and Forex Symbol
        /// </summary>
        public override void Initialize()
        {
            SetStartDate(2001, 10, 07);
            SetEndDate(2010, 10, 11);
            SetCash(250000);

            var allSymbols = StressSymbols.StockSymbols.ToList();//.Concat(ForexSymbols).ToList();
            if (TickSymbolsToRun + SecondSymbolsToRun + HourSymbolsToRun + DailySymbolsToRun > allSymbols.Count)
            {
                throw new Exception("Too many symbols, all symbols: " + allSymbols.Count);
            }

            var hash = new HashSet<string> {"DNY", "MLNK"};
            var ticks = GetRandomSymbols(allSymbols, hash, TickSymbolsToRun).ToList();
            var seconds = GetRandomSymbols(allSymbols, hash, SecondSymbolsToRun).ToList();
            var minutes = GetRandomSymbols(allSymbols, hash, MinuteSymbolsToRun).ToList();
            var hours = GetRandomSymbols(allSymbols, hash, HourSymbolsToRun).ToList();
            var daily = GetRandomSymbols(allSymbols, hash, DailySymbolsToRun).ToList();

            AddSecurity(ticks, Resolution.Tick);
            AddSecurity(seconds, Resolution.Second);
            AddSecurity(minutes, Resolution.Minute);
            AddSecurity(hours, Resolution.Hour);
            AddSecurity(daily, Resolution.Daily);

            //SetUniverse(coarse => coarse.Take(1));
        }
示例#28
0
        /// <summary>
        /// first construct a prime list up to 1k(using seive)
        /// and check each number after 647 to see if it matches with criteria given by the question
        /// 1. for each number, first find out all the prime factors, and add them to a hashset
        /// 2. if prime factors added are not exactly 4, reset the hashset
        /// 3  (start variable is used to make sure the numbers are continuous, if there is a gap between numbers, reset the hashset)
        /// 4. if prime factors added are exactly 4, check the hashset count, if it is 16 return the answer
        /// 5. if it is not 16, continues to next number
        /// </summary>
        /// <returns></returns>
        static int brute_force_test_each_number_for_match()
        {
            var max = 1000; //randomly chose, it works :P
            var bound = (int)Math.Sqrt(max);
            bool[] primes = new bool[max];
            primes[0] = true;
            primes[1] = true;
            int s, m;
            for (s = 2; s <= bound; s++)
            {
                if (primes[s] == false)
                {
                    for (m = s * s; m < max; m += s)
                    {
                        primes[m] = true;
                    }
                }
            }
            var factor = 4;
            var start = 0;
            var num = 0;
            var pwr = 1;
            var set = new HashSet<int>();
            var count = 1;
            for (s = 647; s < 200000; s++)
            {
                num = s;
                for (m = 2; m < max; m++)
                {
                    if (primes[m] == false)
                    {
                        pwr = 1;
                        while (num % m == 0)
                        {
                            pwr *= m;
                            num /= m;
                        }
                        if (pwr != 1)
                            set.Add(pwr);
                        if (num <= 1)
                            break;
                    }
                }
                if (set.Count == factor * count && (s == start + 1 || start == 0))
                {
                    if (count == factor)
                        return s - 3;

                    start = s;
                    count++;
                }
                else
                {
                    set.Clear();
                    count = 1;
                    start = 0;
                }
            }
            return 0;
        }
示例#29
0
    private static void SaveAllConncectedComponents(Node<int> node,
        HashSet<int> visitedNodes, List<string> connectedComponents)
    {
        string graphs = string.Empty;
        Stack<Node<int>> nodesStack = new Stack<Node<int>>();
        nodesStack.Push(node);

        while (nodesStack.Count > 0)
        {
            Node<int> currentNode = nodesStack.Pop();
            visitedNodes.Add(currentNode.Value);
            graphs += " -> " + currentNode.Value;

            foreach (var child in currentNode.Children)
            {
                if (!visitedNodes.Contains(child.Value))
                {
                    visitedNodes.Add(child.Value);
                    nodesStack.Push(child);
                }
            }
        }

        connectedComponents.Add(graphs.Substring(4));
    }
示例#30
0
        private static OrderedMultiDictionary<int, Article> GenerateArticles(int count)
        {
            var barcodes = new HashSet<string>();

            Console.Write("Generating barcodes...");
            while (barcodes.Count < count)
            {
                var barcode = RandomGenerator.GetRandomString(BarcodeLength);
                barcodes.Add(barcode);
                if (barcodes.Count % (count / 10) == 0)
                {
                    Console.Write('.');
                }
            }

            Console.Write("\n\nGenerating articles...");
            var articles = new OrderedMultiDictionary<int, Article>(true);
            foreach (var barcode in barcodes)
            {
                var vendor = RandomGenerator.GetRandomString(5);
                var title = RandomGenerator.GetRandomString(7);
                var price = RandomGenerator.GeneratRandomNumber(0, count);
                var article = new Article(barcode, vendor, title, price);
                articles.Add(price, article);
                if (articles.Count % (count / 10) == 0)
                {
                    Console.Write('.');
                }
            }

            Console.WriteLine();
            return articles;
        }
示例#31
0
 /* goodG2B() - use goodsource and badsink */
 private static void GoodG2B()
 {
     int data = CWE789_Uncontrolled_Mem_Alloc__Database_HashSet_61b.GoodG2BSource();
     /* POTENTIAL FLAW: Create a HashSet using data as the initial size.  data may be very large, creating memory issues */
     HashSet <int> intHashSet = new HashSet <int>(data);
 }
 public TipoPagamentoDao()
 {
     PedidoTipoPagamentoDao = new HashSet <PedidoTipoPagamentoDao>();
 }
示例#33
0
 public CollectionOfficer()
 {
     LeafCollections = new HashSet<LeafCollection>();
     SupplierCollections = new HashSet<SupplierCollection>();
     CollectionOfficerRoutes = new HashSet<CollectionOfficerRoute>();
 }
示例#34
0
        private long SaveMessageVsReturnsDeviceIds(Request model, int type, string arMessage, NotificationType notificationType,
                                                   IQueryable <DeviceSetting> devicesList, ref HashSet <string> hashSet)
        {
            long messageId = 0;

            // notification will be sent to users
            if (type < 4)
            {
                messageId = _UnitOfWork.NotificationDeviceRepository.Add(model.UserId, null, notificationType, arMessage, arMessage, model.Id, false);
                hashSet   =
                    new HashSet <string>(devicesList.Where(u => u.DeviceId != null && u.ApplicationUserId == model.UserId && u.ApplicationUser.IsOnline).Select(x => x.DeviceId).Distinct().ToList());
            }
            //notification canceled by admin and notification will be sent to agent and user
            else if (type == 4)
            {
                messageId = _UnitOfWork.NotificationDeviceRepository.Add(model.UserId, model.AgentId, notificationType, arMessage, arMessage, model.Id, false);
                hashSet   = new HashSet <string>(devicesList.Where(u => u.DeviceId != null && u.ApplicationUserId == model.UserId || u.ApplicationUserId == model.AgentId && u.ApplicationUser.IsOnline).Select(x => x.DeviceId).Distinct().ToList());
            }
            // notification will be sent to user when admin delete agent
            else if (type == 5)
            {
                messageId = _UnitOfWork.NotificationDeviceRepository.Add(model.UserId, null, notificationType, arMessage, arMessage, model.Id, false);
                hashSet   = new HashSet <string>(devicesList.Where(u => u.DeviceId != null && u.ApplicationUserId == model.UserId && u.ApplicationUser.IsOnline).Select(x => x.DeviceId).Distinct().ToList());
            }
            //new request and notifications will be sent to all agents suitable to this request
            if (type == 6)
            {
                var agentids = (_repo.GetAllAgent())
                               .Where(x => (x.Type == (RequestTypesEnum)model.Type || x.Type == RequestTypesEnum.Both) &&
                                      x.CityId == model.CityId && x.Car.PassengerNumberId >= model.PassengerNumberId && x.IsNotified).Select(u => u.Id).ToList();
                messageId = _UnitOfWork.NotificationDeviceRepository.Add(notificationType, arMessage, arMessage, model.Id, agentids, false);
                hashSet   = new HashSet <string>(devicesList.Where(u => u.DeviceId != null && agentids.Contains(u.ApplicationUserId) && u.ApplicationUser.IsOnline && u.ApplicationUser.IsNotified).Select(x => x.DeviceId).Distinct());
            }
            // notification will be sent to agent when user cancel request
            else if (type == 7)
            {
                messageId = _UnitOfWork.NotificationDeviceRepository.Add(model.AgentId, null, notificationType, arMessage, arMessage, model.Id, false);

                hashSet =
                    new HashSet <string>(devicesList.Where(u => u.DeviceId != null && u.ApplicationUserId == model.AgentId && u.ApplicationUser.IsOnline && u.ApplicationUser.IsNotified).Select(x => x.DeviceId).Distinct());
            }
            else if (type == 9)
            {
                messageId = _UnitOfWork.NotificationDeviceRepository.Add(model.AgentId, null, notificationType, arMessage, arMessage, model.Id, false);

                hashSet =
                    new HashSet <string>(devicesList.Where(u => u.DeviceId != null && u.ApplicationUserId == model.AgentId && u.ApplicationUser.IsOnline && u.ApplicationUser.IsNotified).Select(x => x.DeviceId).Distinct());
            }


            return(messageId);
        }
示例#35
0
 public ProductosUsers()
 {
     TransaccionesCuentadestinoNavigation = new HashSet<Transacciones>();
     TransaccionesCuentaorigenNavigation = new HashSet<Transacciones>();
 }
示例#36
0
 public Majors()
 {
     Courses = new HashSet<Courses>();
     Students = new HashSet<Students>();
 }
 public EventByTypeIndexEventFilter(HashSet<string> events)
     : base(false, events)
 {
     _events = events;
     _streams = new HashSet<string>(from eventType in events select "$et-" + eventType);
 }
示例#38
0
			public Decimal CalcTaxableFromTotalAmount(
				PXCache cache,
				object row,
				HashSet<string> taxList,
				DateTime aDocDate,
				Decimal aCuryTotal)
			{
				IComparer<Tax> taxComparer = GetTaxComparer();
				taxComparer.ThrowOnNull(nameof(taxComparer));

				Decimal result = Decimal.Zero;
				PXGraph graph = cache.Graph;
				Dictionary<string, PXResult<Tax, TaxRev>> taxRates = GetTaxRevisionList(graph, aDocDate);
				List<PXResult<Tax, TaxRev>> orderedTaxList = new List<PXResult<Tax, TaxRev>>(taxList.Count);

				foreach (string taxID in taxList)
				{
					if (taxRates.TryGetValue(taxID, out PXResult<Tax, TaxRev> line))
					{
						int idx;
						for (idx = orderedTaxList.Count;
							(idx > 0) && taxComparer.Compare(orderedTaxList[idx - 1], line) > 0;
							idx--)
							;

						var tax = (Tax)line;
						if (_taxCalcMode != null && tax.TaxCalcLevel != CSTaxCalcLevel.CalcOnItemAmtPlusTaxAmt)
						{
							switch (_taxCalcMode)
							{
								case TaxCalculationMode.Net:
									tax.TaxCalcLevel = CSTaxCalcLevel.CalcOnItemAmt;
									break;

								case TaxCalculationMode.Gross:
									tax.TaxCalcLevel = CSTaxCalcLevel.Inclusive;
									break;
							}
						}
						orderedTaxList.Insert(idx, new PXResult<Tax, TaxRev>(tax, (TaxRev)line));
					}
				}

				Decimal rateInclusive = Decimal.Zero;
				Decimal rateLvl1 = Decimal.Zero;
				Decimal rateLvl2 = Decimal.Zero;

				foreach (PXResult<Tax, TaxRev> iRes in orderedTaxList)
				{
					Tax tax = iRes;
					TaxRev taxRev = iRes;
					Decimal multiplier = tax.ReverseTax == true ? Decimal.MinusOne : Decimal.One;

					if (tax.TaxType == CSTaxType.PerUnit)
					{
						PXTrace.WriteError(Messages.PerUnitTaxesNotSupportedOperation);
						throw new PXException(Messages.PerUnitTaxesNotSupportedOperation);
					}

					switch (tax.TaxCalcLevel)
					{
						case CSTaxCalcLevel.Inclusive:
							rateInclusive += multiplier * taxRev.TaxRate.Value;
							break;
						case CSTaxCalcLevel.CalcOnItemAmt:
							rateLvl1 += multiplier * taxRev.TaxRate.Value;
							break;
						case CSTaxCalcLevel.CalcOnItemAmtPlusTaxAmt:
							rateLvl2 += multiplier * taxRev.TaxRate.Value;
							break;
					}
				}

				decimal baseLvl2 = PXDBCurrencyAttribute.RoundCury(cache, row, aCuryTotal / (1 + rateLvl2 / 100), _precision);
				decimal baseLvl1 = PXDBCurrencyAttribute.RoundCury(cache, row, baseLvl2 / (1 + (rateLvl1 + rateInclusive) / 100), _precision);
				Decimal curyTaxTotal = decimal.Zero;
				Decimal curyTax2Total = decimal.Zero;

				foreach (PXResult<Tax, TaxRev> iRes in orderedTaxList)
				{
					Tax tax = iRes;
					TaxRev taxRev = iRes;
					Decimal multiplier = tax.ReverseTax == true ? Decimal.MinusOne : Decimal.One;
					switch (tax.TaxCalcLevel)
					{
						case CSTaxCalcLevel.Inclusive:
							break;
						case CSTaxCalcLevel.CalcOnItemAmt:
							curyTaxTotal += multiplier * PXDBCurrencyAttribute.RoundCury(cache, row, (baseLvl1 * taxRev.TaxRate / 100m) ?? 0m, _precision);
							break;
						case CSTaxCalcLevel.CalcOnItemAmtPlusTaxAmt:
							curyTax2Total += multiplier * PXDBCurrencyAttribute.RoundCury(cache, row, (baseLvl2 * taxRev.TaxRate / 100m) ?? 0m, _precision);
							break;
					}
				}
				result = aCuryTotal - curyTaxTotal - curyTax2Total;
				return result;
			}
示例#39
0
        public void UndoRedo(HashSet <int> layersToRecheck)
        {
            Board board;

            switch (type)
            {
            case UndoRedoType.ItemDeleted:
                //item.Board.BoardItems.Add(item, true);
                item.InsertItem();
                break;

            case UndoRedoType.ItemAdded:
                item.RemoveItem(null);
                break;

            case UndoRedoType.ItemMoved:
                XNA.Point oldPos = (XNA.Point)ParamA;
                item.Move(oldPos.X, oldPos.Y);
                break;

            case UndoRedoType.ItemFlipped:
                ((IFlippable)item).Flip = !((IFlippable)item).Flip;
                break;

            case UndoRedoType.LineRemoved:
                board = ((MapleDot)ParamB).Board;
                if (ParamC is FootholdLine)
                {
                    board.BoardItems.FootholdLines.Add((FootholdLine)ParamC);
                }
                else if (ParamC is RopeLine)
                {
                    board.BoardItems.RopeLines.Add((RopeLine)ParamC);
                }
                else
                {
                    throw new Exception("wrong type at undoredo, lineremoved");
                }
                ((MapleLine)ParamC).FirstDot  = (MapleDot)ParamA;
                ((MapleLine)ParamC).SecondDot = (MapleDot)ParamB;
                ((MapleDot)ParamA).connectedLines.Add((MapleLine)ParamC);
                ((MapleDot)ParamB).connectedLines.Add((MapleLine)ParamC);
                break;

            case UndoRedoType.LineAdded:
                board = ((MapleDot)ParamB).Board;
                if (ParamC is FootholdLine)
                {
                    board.BoardItems.FootholdLines.Remove((FootholdLine)ParamC);
                }
                else if (ParamC is RopeLine)
                {
                    board.BoardItems.RopeLines.Remove((RopeLine)ParamC);
                }
                else
                {
                    throw new Exception("wrong type at undoredo, lineadded");
                }
                ((MapleLine)ParamC).Remove(false, null);
                break;

            case UndoRedoType.ToolTipLinked:
                ((ToolTipInstance)item).CharacterToolTip = null;
                ((ToolTipChar)ParamA).BoundTooltip       = null;
                break;

            case UndoRedoType.ToolTipUnlinked:
                ((ToolTipChar)ParamA).BoundTooltip = (ToolTipInstance)item;
                break;

            case UndoRedoType.BackgroundMoved:
                ((BackgroundInstance)item).BaseX = ((XNA.Point)ParamA).X;
                ((BackgroundInstance)item).BaseY = ((XNA.Point)ParamA).Y;
                break;

            case UndoRedoType.ItemsLinked:
                item.ReleaseItem((BoardItem)ParamA);
                break;

            case UndoRedoType.ItemsUnlinked:
                item.BindItem((BoardItem)ParamA, (Microsoft.Xna.Framework.Point)ParamB);
                break;

            case UndoRedoType.ItemsLayerChanged:
                InputHandler.ClearSelectedItems(((BoardItem)((List <IContainsLayerInfo>)ParamC)[0]).Board);
                foreach (IContainsLayerInfo layerInfoItem in (List <IContainsLayerInfo>)ParamC)
                {
                    layerInfoItem.LayerNumber = (int)ParamA;
                }
                ((BoardItem)((List <IContainsLayerInfo>)ParamC)[0]).Board.Layers[(int)ParamA].RecheckTileSet();
                ((BoardItem)((List <IContainsLayerInfo>)ParamC)[0]).Board.Layers[(int)ParamB].RecheckTileSet();
                break;

            case UndoRedoType.ItemLayerPlatChanged:
                Tuple <int, int>   oldLayerPlat = (Tuple <int, int>)ParamA;
                Tuple <int, int>   newLayerPlat = (Tuple <int, int>)ParamB;
                IContainsLayerInfo li           = (IContainsLayerInfo)ParamC;
                li.LayerNumber    = oldLayerPlat.Item1;
                li.PlatformNumber = oldLayerPlat.Item2;
                layersToRecheck.Add(oldLayerPlat.Item1);
                layersToRecheck.Add(newLayerPlat.Item1);
                break;

            case UndoRedoType.RopeAdded:
                ((Rope)ParamA).Remove(null);
                break;

            case UndoRedoType.RopeRemoved:
                ((Rope)ParamA).Create();
                break;

            case UndoRedoType.ItemZChanged:
                item.Z = (int)ParamA;
                item.Board.BoardItems.Sort();
                break;

            case UndoRedoType.VRChanged:
                //TODO
                break;

            case UndoRedoType.MapCenterChanged:
                //TODO
                break;

            case UndoRedoType.LayerTSChanged:
                string ts_old = (string)ParamA;
                string ts_new = (string)ParamB;
                Layer  l      = (Layer)ParamC;
                l.ReplaceTS(ts_old);
                break;

            case UndoRedoType.zMChanged:
                int zm_old = (int)ParamA;
                int zm_new = (int)ParamB;
                IContainsLayerInfo target = (IContainsLayerInfo)ParamC;
                target.PlatformNumber = zm_old;
                break;
            }
        }
示例#40
0
 public Produkt()
 {
     MatrattProdukt = new HashSet<MatrattProdukt>();
 }
示例#41
0
 public Library()
 {
     Library_Book = new HashSet<Library_Book>();
 }
 public void AddErrors(DocumentId key, HashSet <DiagnosticData> diagnostics)
 => AddErrors(_documentMap, key, diagnostics);
 public void VerifyAnalyzeNodeCalledForAllSyntaxKinds(HashSet<TLanguageKindEnum> syntaxKindsPatterns)
 {
     var expectedSyntaxKinds = AllSyntaxKinds.Where(IsAnalyzeNodeSupported);
     var actualSyntaxKinds = _callLog.Where(a => FilterByAbstractName(a, "SyntaxNode")).Select(e => e.SyntaxKind).Concat(syntaxKindsPatterns).Distinct();
     AssertIsSuperset(expectedSyntaxKinds, actualSyntaxKinds);
 }
示例#44
0
    private void CalculatePassengerMovement(Vector3 velocity) {
        HashSet<Transform> movedPassengers = new HashSet<Transform>();
        passengerMovement = new List<PassengerMovement>();

        float directionX = Mathf.Sign(velocity.x);
        float directionY = Mathf.Sign(velocity.y);

        /*Vertically moving platform*/
        if (velocity.y != 0) {
            float rayLength = Mathf.Abs(velocity.y) + skinWidth;

            for (int i = 0; i < verticalRayCount; i++) {
                Vector2 rayOrigin = directionY == -1 ? raycastOrigins.bottomLeft : raycastOrigins.topLeft;
                rayOrigin += Vector2.right * (verticalRaySpacing * i);

                RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up * directionY, rayLength, passengerMask);
                /*hit.distance checks if the player is inside the platform*/
                if (hit && hit.distance != 0) {
                    if (!movedPassengers.Contains(hit.transform)) {
                        float pushX = directionY == 1 ? velocity.x : 0;
                        float pushY = velocity.y - (hit.distance - skinWidth) * directionY;
                        passengerMovement.Add(new PassengerMovement(hit.transform, new Vector3(pushX, pushY), directionY == 1, true));

                        movedPassengers.Add(hit.transform);
                    }
                }
            }
        }

        /*Horizontally moving platform*/
        if (velocity.x != 0) {
            float rayLength = Mathf.Abs(velocity.x) + skinWidth;

            for (int i = 0; i < horizontalRayCount; i++) {
                Vector2 rayOrigin = directionX == -1 ? raycastOrigins.bottomLeft : raycastOrigins.bottomRight;
                rayOrigin += Vector2.up * (horizontalRaySpacing * i);

                RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, passengerMask);

                if (hit && hit.distance != 0) {
                    if (!movedPassengers.Contains(hit.transform)) {
                        float pushX = velocity.x - (hit.distance - skinWidth) * directionX;
                        float pushY = -skinWidth;
                        passengerMovement.Add(new PassengerMovement(hit.transform, new Vector3(pushX, pushY), false, true));

                        movedPassengers.Add(hit.transform);
                    }
                }
            }
        }

        /*Passenger is on top of horizontally moving platform*/
        if(directionY == -1 || velocity.y == 0 && velocity.x != 0) {
            float rayLength = skinWidth * 2;

            for (int i = 0; i < verticalRayCount; i++) {
                Vector2 rayOrigin = raycastOrigins.topLeft + Vector2.right * (verticalRaySpacing * i);

                RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up, rayLength, passengerMask);
                if (hit && hit.distance != 0) {
                    if (!movedPassengers.Contains(hit.transform)) {
                        float pushX = velocity.x;
                        float pushY = velocity.y - (hit.distance - skinWidth) * directionY;
                        passengerMovement.Add(new PassengerMovement(hit.transform, new Vector3(pushX, pushY), true, false));

                        movedPassengers.Add(hit.transform);
                    }
                }
            }
        }

    }
示例#45
0
 public StudentSubject()
 {
     ExamSubject = new HashSet<ExamSubject>();
 }
示例#46
0
 public override void Bad()
 {
     int data = CWE789_Uncontrolled_Mem_Alloc__Database_HashSet_61b.BadSource();
     /* POTENTIAL FLAW: Create a HashSet using data as the initial size.  data may be very large, creating memory issues */
     HashSet <int> intHashSet = new HashSet <int>(data);
 }
示例#47
0
 public Employees()
 {
     EmployeeTerritories        = new HashSet <EmployeeTerritories>();
     InverseReportsToNavigation = new HashSet <Employees>();
     Orders = new HashSet <Orders>();
 }
示例#48
0
 public Employees()
 {
     Employees1  = new HashSet <Employees>();
     Orders      = new HashSet <Orders>();
     Territories = new HashSet <Territories>();
 }
示例#49
0
 public Account()
 {
     Composition = new HashSet <Composition>();
 }
示例#50
0
 public User()
 {
     Report = new HashSet <Report>();
 }
示例#51
0
 public Product()
 {
     OrderDetails = new HashSet<OrderDetail>();
 }
		/// <inheritdoc />
		public override void OnInspectorGUI()
		{
			this.DrawDefaultInspector();
			
			var gameDataAsset = (Object)this.target;
			var gameDataPath = FileAndPathUtils.MakeProjectRelative(AssetDatabase.GetAssetPath(gameDataAsset));

			var assetPath = FileAndPathUtils.MakeProjectRelative(AssetDatabase.GetAssetPath(Selection.activeObject));
			if (GameDataTracker.IsGameDataFile(assetPath) == false)
			{
				return;
			}

			if (this.lastAsset != gameDataAsset || this.gameDataSettings == null)
			{
				this.gameDataSettings = GameDataSettings.Load(gameDataPath);
				this.gameDataSettings.ScriptingAssemblies = this.gameDataSettings.ScriptingAssemblies ?? new string[0];
				this.lastAsset = gameDataAsset;
				this.newScriptingAssembly = null;
				this.newScriptingAssemblyName = null;
			}
			GUI.enabled = true;
			GUILayout.Label(Path.GetFileName(gameDataPath), EditorStyles.boldLabel);
			this.gameDataSettings.Generator = (int)(GameDataSettings.CodeGenerator)EditorGUILayout.EnumPopup(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATOR, (GameDataSettings.CodeGenerator)this.gameDataSettings.Generator);
			if (this.gameDataSettings.Generator != (int)GameDataSettings.CodeGenerator.None)
			{
				this.codeGenerationFold = EditorGUILayout.Foldout(this.codeGenerationFold, Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATION_LABEL);
				if (this.codeGenerationFold)
				{
					this.gameDataSettings.AutoGeneration = EditorGUILayout.Toggle(Resources.UI_UNITYPLUGIN_INSPECTOR_AUTO_GENERATION,
						this.gameDataSettings.AutoGeneration);
					var codeAsset = !string.IsNullOrEmpty(this.gameDataSettings.CodeGenerationPath) && File.Exists(this.gameDataSettings.CodeGenerationPath) ? AssetDatabase.LoadAssetAtPath<TextAsset>(this.gameDataSettings.CodeGenerationPath) : null;
					var assetAsset = !string.IsNullOrEmpty(this.gameDataSettings.AssetGenerationPath) && File.Exists(this.gameDataSettings.AssetGenerationPath) ? AssetDatabase.LoadAssetAtPath<ScriptableObject>(this.gameDataSettings.AssetGenerationPath) : null;

					if (codeAsset != null)
						this.gameDataSettings.CodeGenerationPath = AssetDatabase.GetAssetPath(EditorGUILayout.ObjectField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATION_PATH, codeAsset, typeof(TextAsset), false));
					else
						this.gameDataSettings.CodeGenerationPath = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATION_PATH,
							this.gameDataSettings.CodeGenerationPath);

					if (this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharpCodeAndAsset)
					{
						if (assetAsset != null)
							this.gameDataSettings.AssetGenerationPath = AssetDatabase.GetAssetPath(EditorGUILayout.ObjectField(Resources.UI_UNITYPLUGIN_INSPECTOR_ASSET_GENERATION_PATH, assetAsset, typeof(ScriptableObject), false));
						else
							this.gameDataSettings.AssetGenerationPath = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_ASSET_GENERATION_PATH, this.gameDataSettings.AssetGenerationPath);
					}

					if ((this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharp ||
						this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharpCodeAndAsset) &&
						Path.GetExtension(this.gameDataSettings.CodeGenerationPath) != ".cs")
						this.gameDataSettings.CodeGenerationPath = Path.ChangeExtension(this.gameDataSettings.CodeGenerationPath, ".cs");
					if (this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharpCodeAndAsset &&
						Path.GetExtension(this.gameDataSettings.AssetGenerationPath) != ".asset")
						this.gameDataSettings.AssetGenerationPath = Path.ChangeExtension(this.gameDataSettings.AssetGenerationPath, ".asset");

					this.gameDataSettings.Namespace = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_NAMESPACE,
						this.gameDataSettings.Namespace);
					this.gameDataSettings.GameDataClassName = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_API_CLASS_NAME,
						this.gameDataSettings.GameDataClassName);
					this.gameDataSettings.DocumentClassName = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_DOCUMENT_CLASS_NAME,
						this.gameDataSettings.DocumentClassName);
					this.gameDataSettings.LineEnding = (int)(GameDataSettings.LineEndings)EditorGUILayout.EnumPopup(
						Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_LINE_ENDINGS, (GameDataSettings.LineEndings)this.gameDataSettings.LineEnding);
					this.gameDataSettings.Indentation = (int)(GameDataSettings.Indentations)EditorGUILayout.EnumPopup(
						Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_INDENTATION, (GameDataSettings.Indentations)this.gameDataSettings.Indentation);
					this.gameDataSettings.Options = (int)(CodeGenerationOptions)EditorGUILayout.EnumMaskField(
						Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_OPTIONS, (CodeGenerationOptions)this.gameDataSettings.Options);
				}
			}

			this.scriptingAssembliesFold = EditorGUILayout.Foldout(this.scriptingAssembliesFold, Resources.UI_UNITYPLUGIN_INSPECTOR_SCRIPTING_ASSEMBLIES_LABEL);
			if (this.scriptingAssembliesFold)
			{
				for (var i = 0; i < this.gameDataSettings.ScriptingAssemblies.Length; i++)
				{
					var watchedAssetPath = this.gameDataSettings.ScriptingAssemblies[i];
					var assetExists = !string.IsNullOrEmpty(watchedAssetPath) && (File.Exists(watchedAssetPath) || Directory.Exists(watchedAssetPath));
					var watchedAsset = assetExists ? AssetDatabase.LoadMainAssetAtPath(watchedAssetPath) : null;
					if (watchedAsset != null)
						this.gameDataSettings.ScriptingAssemblies[i] = AssetDatabase.GetAssetPath(EditorGUILayout.ObjectField(Resources.UI_UNITYPLUGIN_INSPECTOR_ASSET_LABEL, watchedAsset, typeof(Object), false));
					else
						this.gameDataSettings.ScriptingAssemblies[i] = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_NAME_LABEL, watchedAssetPath);
				}
				EditorGUILayout.Space();
				this.newScriptingAssembly = EditorGUILayout.ObjectField("<" + Resources.UI_UNITYPLUGIN_INSPECTOR_ADD_ASSET_BUTTON + ">", this.newScriptingAssembly, typeof(Object), false);
				if (Event.current.type == EventType.repaint && this.newScriptingAssembly != null)
				{
					var assemblies = new HashSet<string>(this.gameDataSettings.ScriptingAssemblies);
					assemblies.Remove("");
					assemblies.Add(AssetDatabase.GetAssetPath(this.newScriptingAssembly));
					this.gameDataSettings.ScriptingAssemblies = assemblies.ToArray();
					this.newScriptingAssembly = null;
					GUI.changed = true;
				}
				EditorGUILayout.BeginHorizontal();
				this.newScriptingAssemblyName = EditorGUILayout.TextField("<" + Resources.UI_UNITYPLUGIN_INSPECTOR_ADD_NAME_BUTTON + ">", this.newScriptingAssemblyName);
				if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_ADD_BUTTON, EditorStyles.toolbarButton, GUILayout.Width(70), GUILayout.Height(18)))
				{
					var assemblies = new HashSet<string>(this.gameDataSettings.ScriptingAssemblies);
					assemblies.Remove("");
					assemblies.Add(this.newScriptingAssemblyName);
					this.gameDataSettings.ScriptingAssemblies = assemblies.ToArray();
					this.newScriptingAssemblyName = null;
					GUI.changed = true;
					this.Repaint();
				}
				GUILayout.Space(5);
				EditorGUILayout.EndHorizontal();
			}

			EditorGUILayout.Space();
			GUILayout.Label(Resources.UI_UNITYPLUGIN_INSPECTOR_ACTIONS_GROUP, EditorStyles.boldLabel);

			if (EditorApplication.isCompiling)
				EditorGUILayout.HelpBox(Resources.UI_UNITYPLUGIN_COMPILING_WARNING, MessageType.Warning);
			else if (CoroutineScheduler.IsRunning)
				EditorGUILayout.HelpBox(Resources.UI_UNITYPLUGIN_COROUTINE_IS_RUNNIG_WARNING, MessageType.Warning);

			EditorGUILayout.BeginHorizontal();
			GUI.enabled = !CoroutineScheduler.IsRunning && !EditorApplication.isCompiling;
			if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_EDIT_BUTTON))
			{
				AssetDatabase.OpenAsset(gameDataAsset);
				this.Repaint();
			}
			if (this.gameDataSettings.Generator != (int)GameDataSettings.CodeGenerator.None && string.IsNullOrEmpty(this.gameDataSettings.CodeGenerationPath) == false)
			{
				if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_RUN_GENERATOR_BUTTON))
				{
					CoroutineScheduler.Schedule(Menu.GenerateCodeAndAssetsAsync(gameDataPath, ProgressUtils.ReportToLog(Resources.UI_UNITYPLUGIN_INSPECTOR_GENERATION_PREFIX + " ")), "generation::" + gameDataPath)
						.ContinueWith(_ => this.Repaint());
				}
			}
			GUI.enabled = !CoroutineScheduler.IsRunning && !EditorApplication.isCompiling;
			if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_VALIDATE_BUTTON))
			{
				CoroutineScheduler.Schedule(Menu.ValidateAsync(gameDataPath, ProgressUtils.ReportToLog(Resources.UI_UNITYPLUGIN_INSPECTOR_VALIDATION_PREFIX + " ")), "validation::" + gameDataPath)
					.ContinueWith(_ => this.Repaint());
			}
			if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_BACKUP_BUTTON))
			{
				this.Backup(gameDataPath);
			}
			if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_RESTORE_BUTTON))
			{
				this.Restore(gameDataPath);
			}
			EditorGUILayout.EndHorizontal();
			GUI.enabled = true;

			if (GUI.changed)
			{
				this.gameDataSettings.Save(gameDataPath);
			}
		}
示例#53
0
 public User()
 {
     Tweets = new HashSet <Tweet>();
 }
示例#54
0
 public Supplier()
 {
     Phones = new HashSet<Phone>();
 }
 public void AddErrors(ProjectId key, HashSet <DiagnosticData> diagnostics)
 => AddErrors(_projectMap, key, diagnostics);
示例#56
0
 public OrderLineItem()
 {
     Configurations = new HashSet<ProductConfiguration>();
 }
示例#57
0
        public Cocept()
        {
            Relations relations = new Relations();

            Console.WriteLine("Матрица смежности:");
            for (int i = 0; i < relations.size; i++)
            {
                for (int j = 0; j < relations.size; j++)
                {
                    Console.Write(relations.matrix[i, j] + " ");
                }
                Console.WriteLine();
            }

            HashSet <List <int> > crossing = new HashSet <List <int> >();

            for (int i = 0; i < relations.size; i++)
            {
                List <int> tempCrossing = new List <int>();
                for (int j = 0; j < relations.size; j++)
                {
                    if (relations.matrix[j, i] == 1)
                    {
                        tempCrossing.Add(j + 1);
                    }
                }
                crossing.Add(tempCrossing);
            }

            while (true)
            {
                int flag = crossing.Count();

                for (int i = 0; i < crossing.Count; i++)
                {
                    for (int j = i + 1; j < crossing.Count; j++)
                    {
                        List <int> tempCrossing = new List <int>();
                        foreach (var item in crossing.ElementAt(i))
                        {
                            if (crossing.ElementAt(j).Contains(item))
                            {
                                tempCrossing.Add(item);
                            }
                        }
                        bool flag2 = true;
                        for (int l = 0; l < crossing.Count; l++)
                        {
                            if (tempCrossing.Count == crossing.ElementAt(l).Count)
                            {
                                for (int t = 0; t < crossing.ElementAt(l).Count; t++)
                                {
                                    if (!(crossing.ElementAt(l).Contains(tempCrossing[t])))
                                    {
                                        break;
                                    }
                                    flag2 = false;
                                }
                            }
                        }
                        if (flag2)
                        {
                            if (tempCrossing.Count == 0)
                            {
                                if (!(crossing.ElementAt(crossing.Count - 1).Count == 0))
                                {
                                    crossing.Add(tempCrossing);
                                }
                            }
                            else
                            {
                                crossing.Add(tempCrossing);
                            }
                        }
                    }
                }

                if (flag == crossing.Count())
                {
                    break;
                }
            }

            List <int> allElement = new List <int>();

            for (int i = 1; i < relations.size; i++)
            {
                allElement.Add(i);
            }

            bool flag4 = true;

            for (int l = 0; l < crossing.Count; l++)
            {
                if (allElement.Count == crossing.ElementAt(l).Count)
                {
                    for (int t = 0; t < crossing.ElementAt(l).Count; t++)
                    {
                        if (!(crossing.ElementAt(l).Contains(allElement[t])))
                        {
                            break;
                        }
                        flag4 = false;
                    }
                }
            }

            if (flag4)
            {
                crossing.Add(allElement);
            }

            List <List <List <int> > > neighbours = new List <List <List <int> > >();

            for (int i = 0; i < crossing.Count; i++)
            {
                neighbours.Add(new List <List <int> >());
                for (int j = 0; j < crossing.Count; j++)
                {
                    bool flag = true;
                    if (i != j)
                    {
                        for (int k = 0; k < crossing.ElementAt(i).Count; k++)
                        {
                            if (!(crossing.ElementAt(j).Contains(crossing.ElementAt(i)[k])))
                            {
                                flag = false;
                                break;
                            }
                        }
                    }
                    if (flag && i != j)
                    {
                        neighbours.ElementAt(i).Add(crossing.ElementAt(j));
                    }
                }
            }

            //идем по всем пересечениям
            for (int i = 0; i < crossing.Count; i++)
            {
                List <List <int> > temp = new List <List <int> >(neighbours.ElementAt(i));
                //по соседям пересечения
                for (int j = 0; j < temp.Count; j++)
                {
                    //ищем номер соседа в пересечении
                    int numb = 0;
                    for (int n = 0; n < crossing.Count; n++)
                    {
                        if (crossing.ElementAt(n).Count == temp[j].Count)
                        {
                            bool flag = true;
                            for (int l = 0; l < crossing.ElementAt(n).Count; l++)
                            {
                                if (!(crossing.ElementAt(n)[l] == temp[j][l]))
                                {
                                    flag = false;
                                    break;
                                }
                            }
                            if (flag)
                            {
                                numb = n;
                                break;
                            }
                        }
                    }
                    for (int n = 0; n < neighbours.ElementAt(numb).Count; n++)
                    {
                        if (temp.Contains(neighbours.ElementAt(numb)[n]))
                        {
                            neighbours.ElementAt(i).Remove(neighbours.ElementAt(numb)[n]);
                        }
                    }
                }
            }

            List <List <List <int> > > levels = new List <List <List <int> > >();

            levels.Add(neighbours.ElementAt(neighbours.Count - 1));

            bool flag3 = true;

            while (flag3)
            {
                levels.Add(new List <List <int> >());
                for (int i = 0; i < levels.ElementAt(levels.Count - 2).Count; i++)
                {
                    int numb = 0;
                    for (int n = 0; n < crossing.Count; n++)
                    {
                        if (crossing.ElementAt(n).Count == levels.ElementAt(levels.Count - 2)[i].Count)
                        {
                            bool flag = true;
                            for (int l = 0; l < crossing.ElementAt(n).Count; l++)
                            {
                                if (!(crossing.ElementAt(n)[l] == levels.ElementAt(levels.Count - 2)[i][l]))
                                {
                                    flag = false;
                                    break;
                                }
                            }
                            if (flag)
                            {
                                numb = n;
                                break;
                            }
                        }
                    }
                    for (int j = 0; j < neighbours.ElementAt(numb).Count; j++)
                    {
                        if (!(levels[levels.Count - 1].Contains(neighbours.ElementAt(numb)[j])))
                        {
                            levels[levels.Count - 1].Add(neighbours.ElementAt(numb)[j]);
                            if (neighbours.ElementAt(numb)[j].Count == relations.size)
                            {
                                flag3 = false;
                            }
                        }
                    }
                }
            }

            string alph = "abcdefghijklmnopqrstuvwxyz";

            for (int i = 0; i < levels.Count; i++)
            {
                Console.WriteLine("{0} уровень:", i);
                foreach (var item in levels[i])
                {
                    List <int> temp = new List <int>();
                    Console.Write("{");
                    foreach (var num in item)
                    {
                        Console.Write(num + " ");
                        temp.Add(num);
                    }
                    Console.Write("}");

                    Console.Write("{");
                    for (int j = 0; j < relations.size; j++)
                    {
                        bool flag = true;
                        for (int j2 = 0; j2 < temp.Count; j2++)
                        {
                            if (relations.matrix[temp[j2] - 1, j] == 0)
                            {
                                flag = false;
                            }
                        }
                        if (flag)
                        {
                            Console.Write(alph.ElementAt(j) + " ");
                        }
                    }
                    Console.Write("}");
                }
                Console.WriteLine();
            }

            int index = 0;

            foreach (var item in crossing)
            {
                Console.Write("{");
                foreach (var num in item)
                {
                    Console.Write(num + " ");
                }
                Console.Write("}:");
                foreach (var neigb in neighbours[index])
                {
                    Console.Write("{");
                    foreach (var num in neigb)
                    {
                        Console.Write(num + " ");
                    }
                    Console.Write("}");
                }
                Console.WriteLine();
                index++;
            }
        }
示例#58
0
 public Autores()
 {
     Livros = new HashSet<Livros>();
 }
 public Illustration()
 {
     ProductModelIllustrations = new HashSet<ProductModelIllustration>();
 }
示例#60
0
 public Vacancy()
 {
     SkillRequirements = new HashSet<SkillRequirement>();
     VacancyCities = new HashSet<VacancyCity>();
     CVs = new HashSet<VacancyCVFlow>();
 }