Example #1
0
        public List<Edge<int>> mfas(BidirectionalGraph<int, Edge<int>> G)
        {
            List<Edge<int>> F = new List<Edge<int>>();
            IDictionary<int, int> P = new Dictionary<int, int>();

            int sccCount = G.StronglyConnectedComponents(out P);

            if (sccCount == 0)
            {
                return F;
            }

            if (sccCount == 1)
            {
                Tuple<List<int>, List<int>> T = bisect(G);
                F = mfas(subGraph(T.Item1, G));
                F.AddRange(mfas(subGraph(T.Item2, G)));
                F.AddRange(fromV2toV1(T, G));
            }
            else
            {
                var scc = new HashSet<int>(P.Values);
                foreach (int k in scc)
                {
                    List<int> S = P.Select(x => x).Where(x => x.Value == k).Select(x => x.Key).ToList<int>();
                    F.AddRange(mfas(subGraph(S, G)));
                }
            }

            return F;
        }
 public static Dictionary<string, PropertyInfo> ApplyPropertyCasing(DeserializationContext context, Dictionary<string, PropertyInfo> properties)
 {
     if (context.JsonContractResolver is CamelCasePropertyNamesContractResolver)
     {
         var camel = new Func<string, string>(name => string.Format("{0}{1}", name.Substring(0,1).ToLowerInvariant(), name.Substring(1, name.Length-1)));
         return properties.Select(x => new { Key = camel(x.Key), x.Value }).ToDictionary(x => x.Key, x => x.Value);
     }
     return properties;
 }
 private static string DictToString(Dictionary<string, object> dict)
 {
     var res = string.Join("; ", dict.Select(
         p => string.Format(
         "{0}, {1}"
         ,   p.Key
         ,   p.Value != null ? p.Value.ToString() : ""
         )
         ).ToArray());
     return res.ToString ();
 }
		protected void Page_Load(object sender, EventArgs e)
		{
			if (!Page.IsPostBack)
			{
				
				
				DsiPage page = (DsiPage)this.Page;

				var musicTypes = new Dictionary<string, int>() {{"All Music", 0}};
				var musicTypeSet = new MusicTypeSet(new Query(new Q(Bobs.MusicType.Columns.K, page.RelevantMusic.ToArray())));
				foreach (var musicType in musicTypeSet)
				{
					musicTypes[musicType.Name] = musicType.K;
				}
				foreach (var musicType in Identity.Current.FavouriteMusicTypes.ConvertAll(k => new MusicType(k)))
				{
					musicTypes[musicType.Name] = musicType.K;
				}
				this.uiMusicTypes.Items.AddRange(musicTypes.Select(mt => new ListItem(mt.Key, mt.Value.ToString())).ToArray());

				var places = new Dictionary<string, int>() {{"Anywhere", -1}};
				var placeSet = new PlaceSet(new Query(new Q(Bobs.Place.Columns.K, page.RelevantMusic.ToArray())));
				foreach (var place in placeSet)
				{
					places[place.Name] = place.K;
				}
				foreach (var place in Identity.Current.PlacesVisited.ConvertAll(k => new Place(k)))
				{
					places[place.Name] = place.K;
				}
				this.uiPlaces.Items.AddRange(places.Select(mt => new ListItem(mt.Key, mt.Value.ToString())).ToArray());
			}
			//if (Common.Settings.UseCometToServeRequests)
			//{
			//    this.uiBuddyMultiSelector.WebServiceMethod = "";
			//    this.uiBuddyMultiSelector.WebServiceUrl = "";
			//    this.uiBuddyMultiSelector.CometServiceUrl = @"/WebServices/CometAutoComplete/GetBuddiesThenUsrs.ashx";
			//}

			uiBuddyMultiSelector.TextBoxTabIndex = TabIndexBase + 1;
			uiJustBuddiesRadio.TabIndex = (short)(TabIndexBase + 2);
			uiAllMembersRadio.TabIndex = (short)(TabIndexBase + 3);
			uiShowBuddyList.TabIndex = (short)(TabIndexBase + 4);
			uiBuddyList.TabIndex = (short)(TabIndexBase + 5);
			uiShowAddAll.TabIndex = (short)(TabIndexBase + 6);
			uiAddAllButton.Attributes["tabindex"] = (TabIndexBase + 7).ToString();
			uiShowAddBy.TabIndex = (short)(TabIndexBase + 8);
			uiPlaces.TabIndex = (short)(TabIndexBase + 9);
			uiMusicTypes.TabIndex = (short)(TabIndexBase + 10);
			uiAddByMusicAndPlace.Attributes["tabindex"] = (TabIndexBase + 11).ToString();
			uiShowAllTownsAndMusic.TabIndex = (short)(TabIndexBase + 12);


		}
Example #5
0
 public static string CreateQueryString(Dictionary<string, object> dict)
 {
     return (dict == null || dict.Count == 0)
     ?	string.Empty
     :	CreateQueryString(
             dict.Select(kv =>
                 kv.Value is bool
                     ? new KeyValuePair<string, string>(kv.Key, (bool)kv.Value ? "1" : "0")
                     : new KeyValuePair<string, string>(kv.Key, kv.Value != null ? kv.Value.ToString() : null)
             )
         );
 }
 protected override object DoDeserializeValue(XmlReader reader, bool isSimpleValue)
 {
   IDictionary<string, MediaCategory_DTO> result_dtos = new Dictionary<string, MediaCategory_DTO>();
   if (SoapHelper.ReadEmptyStartElement(reader)) // Read start of enclosing element
     return new List<MediaCategory>();
   while (reader.NodeType != XmlNodeType.EndElement)
   {
     MediaCategory_DTO result_dto = MediaCategory_DTO.Deserialize(reader);
     result_dtos.Add(result_dto.CategoryName, result_dto);
   }
   reader.ReadEndElement(); // End of enclosing element
   return new List<MediaCategory>(result_dtos.Select(mCatDtoKvp => mCatDtoKvp.Value.GetMediaCategory(result_dtos)));
 }
Example #7
0
        // Methods
        public static string Serialize(object value = null, string prefix = null)
        {
            // Require
            if (value == null) return string.Empty;

            // Result
            var nameValueDictionary = new Dictionary<string, string>();

            // Serialize
            SerializeObject(ref nameValueDictionary, value, prefix);

            // Return
            return string.Join("&", nameValueDictionary.Select(nameValuePair => (nameValuePair.Key + "=" + Uri.EscapeDataString(nameValuePair.Value))));
        }
        /// <summary>
        ///     Updates errorEntryList with a page of errors from the repository in descending order of logged time and returns
        ///     total number of entries
        /// </summary>
        public override int GetErrors(int pageIndex, int pageSize, IList errorEntryList)
        {
            var errors = new Dictionary<string, ErrorRecord>();

            // todo: proper async support
            var totalCount = _errorRepository.GetErrorsAsync(pageIndex, pageSize, errors).Result;
            var errorLogEntries = errors.Select(error => new ErrorLogEntry(this, error.Key, error.Value.ToError()));

            foreach (var errorLogEntry in errorLogEntries)
            {
                errorEntryList.Add(errorLogEntry);
            }

            return totalCount;
        }
Example #9
0
        private static void OnGameLoad(EventArgs args)
        {
            try
            {
                pSkins = GetSkins(ObjectManager.Player.ChampionName);

                Config = new Menu("鐨偆淇敼", "Skin Changer", true);
                var SelectedSkin = Config.AddItem(new MenuItem("currentSkin", " ").SetValue(new StringList(pSkins.Select(item => item.Value).ToArray())).DontSave());
                var SwitchSkin = Config.AddItem(new MenuItem("keySwitch", "鐐规垜淇敼").SetValue(new KeyBind("9".ToCharArray()[0], KeyBindType.Press)));

                SelectedSkin.ValueChanged += (object sender, OnValueChangeEventArgs vcArgs) =>
                {
                    Packet.S2C.UpdateModel.Encoded(new Packet.S2C.UpdateModel.Struct(ObjectManager.Player.NetworkId, vcArgs.GetNewValue<StringList>().SelectedIndex, ObjectManager.Player.ChampionName)).Process(PacketChannel.S2C);
                };
            {

            Config.AddSubMenu(new Menu("L#涓枃绀惧尯姹夊寲", "LOLL35.Com"));
                Config.SubMenu("LOLL35.Com").AddItem(new MenuItem("wangzhi", "www.loll35.com"));
                Config.SubMenu("LOLL35.Com").AddItem(new MenuItem("qunhao2", "姹夊寲缇わ細397983217"));
            }

                SwitchSkin.ValueChanged += (object sender, OnValueChangeEventArgs vcArgs) =>
                {
                    if (vcArgs.GetOldValue<KeyBind>().Active) return;

                    var currentSkin = Config.Item("currentSkin");
                    var OldValues = currentSkin.GetValue<StringList>();
                    var newSkinId = OldValues.SelectedIndex + 1 >= OldValues.SList.Count() ? 0 : OldValues.SelectedIndex + 1;
                    currentSkin.SetValue(new StringList(OldValues.SList, newSkinId));
                };

                Config.AddToMainMenu();

                Game.PrintChat("<font color=\"#0066FF\">[<font color=\"#FFFFFF\">madk</font>]</font><font color=\"#FFFFFF\"> Skin Changer loaded!</font>");
            }
            catch(Exception ex)
            {
                Game.PrintChat("<font color=\"#0066FF\">[<font color=\"#FFFFFF\">madk</font>]</font><font color=\"#FFFFFF\"> An error ocurred loading Skin Changer.</font>");

                Console.WriteLine("~~ Skin Changer exception found ~~");
                Console.WriteLine(ex);
                Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            }
        }
 /// <summary>
 /// Given a Lucene Query, this will build the facets and append them to find the Bit comparison of two queries.
 /// </summary>
 /// <returns>List of FacetReturn</returns>
 /// <param name="query">The initial query</param>
 /// <param name="searchQuery">The raw search query</param>
 /// <param name="locationFilter">The location used to determine which index to use</param>
 /// <param name="baseQuery">The initial queries bit array</param>
 public List<FacetReturn> Filter(Query query, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery)
 {
     var listOfDates = new Dictionary<DateTime, string>
         {
             { DateTime.Now.AddDays(-1), "Within a Day" },
             { DateTime.Now.AddDays(-7), "Within a Week" },
             { DateTime.Now.AddMonths(-1), "Within a Month" },
             { DateTime.Now.AddYears(-1), "Within a Year" },
             { DateTime.Now.AddYears(-3), "Older" }
         };
     var returnFacets =
                   this.GetSearch(query, listOfDates.Select(date => date.Key.ToString() + "|" + date.Value).ToList(), searchQuery, locationFilter, baseQuery).Select(
                   facet =>
                   new FacetReturn
                       {
                           KeyName = DecodeDateSearch(DateTime.Parse(facet.Key.Split('|')[0]), listOfDates),
                           Value = facet.Value.ToString(),
                           Type = "date range"
                       });
     return returnFacets.ToList();
 }
 /// <summary>
 /// Creates a grammatical relationship
 /// </summary>
 /// <param name="predicate">The main action or verb acting on the first argument, or the action connecting multiple arguments.</param>
 /// <param name="arguments">The mention(s), mapped to the argument number, of one or more arguments in the relationship</param>
 /// <param name="IDs">The IDs of the arguments, mapped to the corresponding argument number.  The ID with key 1 should correspond to the argument with key 1.</param>
 /// <param name="temporals">Time frames of the action.  May be empty.</param>
 /// <param name="locatives">Locations of the action.  May be empty.</param>
 /// <param name="adjunts">All other parts of the relationship.  May be empty.</param>
 /// <param name="confidence">A score for each relationship result, ranging from 0 to 1. You can use this measurement as a threshold to filter out undesired results.</param>
 /// <param name="modalities">The modalities of the relationship.</param>
 public RosetteRelationship(string predicate, Dictionary<int, string> arguments, Dictionary<int, string> IDs, List<string> temporals, List<string> locatives, List<string> adjunts, Nullable<decimal> confidence, HashSet<string> modalities)
 {
     this.Predicate = predicate;
     #pragma warning disable 618
     this.Arguments = arguments.Select(kvp => kvp.Value).ToList();
     this.ArgumentsFull = new List<Argument>(arguments.Select<KeyValuePair<int, string>, Argument>((kvp, index) => new Argument(kvp.Key, kvp.Value, IDs == null || !IDs.ContainsKey(kvp.Key) || IDs[kvp.Key] == null ? null : new EntityID(IDs[kvp.Key]))));
     #pragma warning restore 618
     this.Temporals = temporals;
     this.Locatives = locatives;
     this.Adjucts = adjunts;
     this.Confidence = confidence;
     this.Modalities = modalities;
 }
Example #12
0
        private static void testCAPTCHA()
        {
            var timer = new MyTimer();
            int s = 100, K = 100, m = 180;

            string[] templatefiles = Directory.GetFiles(@"D:\Play Data\my_template_data\scq-" + K + "-" + m, "*.scq")
                .Take(10000).ToArray();
            #region 打开量化的模板
            int templatecount = templatefiles.Length;
            Debug("打开{0}个量化模板----------------------------------------", templatecount);
            timer.Restart();
            int[][] templatehistograms = new int[templatecount][];
            string[] templatechars = new string[templatecount];
            for (int f = 0; f < templatecount; ++f) {
                string file = templatefiles[f];
                string filename = Path.GetFileNameWithoutExtension(file);
                templatechars[f] = filename.Split('-')[1];
                templatehistograms[f] = new int[K];
                using (var fs = new FileStream(file, FileMode.Open)) {
                    using (var br = new BinaryReader(fs)) {
                        for (int i = 0; i < K; ++i) {
                            templatehistograms[f][i] = br.ReadInt32();
                        }
                    }
                }
            }
            Debug("打开完成,用时{0}ms.", timer.Stop());

            #endregion

            #region 打开Shapeme
            Debug("打开{0}个Shapeme.", K);
            timer.Restart();
            double[][] shapemes = new double[K][];
            using (var fs = new FileStream(Path.Combine(@"D:\Play Data\my_template_data\sm-" + K, m + ".sm"), FileMode.Open)) {
                using (var br = new BinaryReader(fs)) {
                    for (int i = 0; i < K; ++i) {
                        shapemes[i] = new double[60];
                        for (int k = 0; k < 60; ++k) {
                            shapemes[i][k] = br.ReadDouble();
                        }
                    }
                }
            }

            Debug("Shapeme读取完成,用时{0}ms.", timer.Stop());
            #endregion

            #region 识别
            foreach (var challengeFile in Directory.GetFiles(@"D:\Play Data\字符\", "*.jpg")) {
                timer.Restart();
                string filename = Path.GetFileNameWithoutExtension(challengeFile);
                Image<Gray, Byte> img = new Image<Gray, byte>(challengeFile);
                var mmp = img.Convert<Bgr, Byte>();
                Graphics g = Graphics.FromImage(mmp.Bitmap);
                double width_height_ratio = (double)img.Width / img.Height;
                int sq = (int)(s * width_height_ratio * 1.2);
                int randcount = (int)(width_height_ratio * 2);
                //int windowcount = (int)(width_height_ratio * 2),
                //    windowstep = (int)(img.Width / windowcount),
                //    windowwidth = (int)(img.Width * 1.5 / windowcount);
                //int maxrandcount = randcount * 3;
                //Console.WriteLine("宽高比{0:F2},采样{1},随机数{2},随机上限{3}.",
                //    width_height_ratio, sq, randcount, maxrandcount);
                int slice = 16,//(int)(width_height_ratio * width_height_ratio),
                    overlap = 4,
                    windowcount = 7;//slice - (overlap - 1);
                double slice_width = (double)img.Width / slice;
                Console.WriteLine("宽高比{0:F2},切片数{1},切片宽度{2:F2},窗口数{3}.",
                    width_height_ratio, slice, slice_width, windowcount);
                var edge = getEdge(img).Sample(sq);
                foreach (var p in edge) {
                    mmp[p] = new Bgr(0, 0, 127);
                }
                bool[] edge_vi = Utils.InitArray(sq, false);
                #region 计算采样点之间的距离
                ValueIndexPair<double>[][] edgedists = new ValueIndexPair<double>[sq][];
                for (int i = 0; i < sq; ++i) {
                    edgedists[i] = new ValueIndexPair<double>[sq];
                    for (int j = 0; j < sq; ++j) {
                        double xi = edge[i].X, yi = edge[i].Y,
                               xj = edge[j].X, yj = edge[j].Y;
                        double d = Math.Sqrt((xi - xj) * (xi - xj) + (yi - yj) * (yi - yj));
                        edgedists[i][j] = new ValueIndexPair<double> { Value = d, Index = j };
                    }
                    Array.Sort(edgedists[i], (a, b) => a.Value.CompareTo(b.Value));
                }
                #endregion

                var charlist = new List<Tuple<string, int, PointF>>(); // <ch, count, center>
                //for (int rc = 0, rt = 0; rc < randcount && rt < maxrandcount; ++rt) {
                //    #region 随机取一个中心点,并且取离他近的点计算形状上下文
                //int center = rand.Next(sq);
                //if (edge_vi[center]) continue;
                //else rc++;
                //rc++;
                //var nearby = new List<Point>();
                //foreach (var pair in edgedists[center].Take((int)(s * 1.5))) {
                //    nearby.Add(edge[pair.Index]);
                //    edge_vi[pair.Index] = true;
                //}
                //nearby = nearby.Sample(s);
                for (int wd = 0; wd < windowcount; ++wd) {
                    #region 滑动窗口位置
                    //int window_center = wd * windowstep + (windowwidth / 2);
                    double window_center = (wd * 2 + overlap / 2.0) * slice_width;
                    g.DrawLine(Pens.Green, (float)window_center, 0, (float)window_center, img.Height);
                    var nearby = edge.Where(p => Math.Abs(p.X - window_center) < img.Height)
                                     .OrderBy(p => Math.Abs(p.X - window_center))
                                     .Take((int)(s * 1.2))
                                     .ToList().Sample(s);
                    if (nearby.Average(p => Math.Abs(p.X - window_center)) > img.Height) continue;
                    var sc = Jim.OCR.ShapeContext2D.ShapeContext.ComputeSC2(nearby);

                    #endregion

                    #region 对待测图的形状上下文进行量化

                    int[] histogram = new int[K];
                    for (int i = 0; i < s; ++i) {
                        double[] ds = new double[K];
                        for (int j = 0; j < K; ++j)
                            ds[j] = Jim.OCR.ShapeContext2D.ShapeContext.HistCost(sc[i], shapemes[j]);
                        int id = ds.Select((v, idx) => new ValueIndexPair<double> { Value = v, Index = idx })
                            .OrderBy(p => p.Value)
                            .First().Index;
                        ++histogram[id];
                    }

                    #endregion

                    #region 计算量化后的比较距离

                    double[] dists = new double[templatecount];
                    for (int i = 0; i < templatecount; ++i) {
                        //dists[i] = Jim.OCR.ShapeContext2D.ShapeContext.ChiSquareDistance(histogram, templatehistograms[i]);
                        dists[i] = Jim.OCR.ShapeContext2D.ShapeContext.HistCost(
                            histogram.Select(d => (double)d).ToArray(),
                            templatehistograms[i].Select(d => (double)d).ToArray());
                    }

                    #endregion

                    #region 对结果进行排序和统计

                    var arr = dists.Select((d, i) => new ValueIndexPair<double> { Value = d, Index = i })
                        .OrderBy(p => p.Value)
                        .Select(p => new { Distance = p.Value, Char = templatechars[p.Index] })
                        .Where(p => "0123456789".IndexOf(p.Char) != -1)
                        .ToArray();
                    Dictionary<string, int> matchcount = new Dictionary<string, int>();
                    int knn = 10;
                    foreach (var pair in arr.Take(knn)) {
                        string ch = pair.Char;
                        matchcount[ch] = matchcount.ContainsKey(ch) ? matchcount[ch] + 1 : 1;
                    }
                    var match = matchcount.Select(pair => new { Count = pair.Value, Ch = pair.Key })
                        .Where(v => v.Count > 0)
                        .OrderByDescending(v => v.Count).ToArray();
                    var firstmatch = match[0];
                    PointF newcenter = new PointF(nearby.Average(p => (float)p.X), nearby.Average(p => (float)p.Y));
                    charlist.Add(new Tuple<string, int, PointF> {
                        First = firstmatch.Ch,
                        Second = firstmatch.Count,
                        Third = newcenter
                    });

                    #endregion
                }
                foreach (var tp in charlist) {
                    string ch = tp.First;
                    int acc = tp.Second;
                    PointF center = tp.Third;
                    //g.DrawString(num.ToString(), new Font("Arial", 24), new SolidBrush(Color.FromArgb(40 + 20 * acc, 0, 0)),
                    //            new PointF(center.X - 12, center.Y - 12));
                    g.DrawString(ch, new Font("Arial", 24), (acc >= 5 ? Brushes.Red : Brushes.DarkGreen),
                                new PointF(center.X - 12, center.Y - 12));
                }
                mmp.Save(Path.Combine(@"D:\Play Data\测试玩意\", filename + ".jpg"));
                Debug("{0}-{1}ms", filename, timer.Stop());

            }
            #endregion
        }
Example #13
0
        public void CheckOrder(OrderMaster orderMaster)
        {
            BusinessException ex = new BusinessException();
            if (orderMaster.Type == com.Sconit.CodeMaster.OrderType.CustomerGoods
                || orderMaster.Type == com.Sconit.CodeMaster.OrderType.Procurement)
            {
                ex.AddMessage("订单" + orderMaster.OrderNo + "无需检查库存");
            }
            else
            {
                var paramList = new List<object>();
                string sql = string.Empty;
                paramList.Add(orderMaster.LocationFrom);

                var itemQtyDic = new Dictionary<string, decimal>();
                if (orderMaster.Type == CodeMaster.OrderType.Production)
                {
                    TryLoadOrderBomDetails(orderMaster);
                    if (orderMaster.OrderDetails != null)
                    {
                        itemQtyDic = orderMaster.OrderDetails
                            .SelectMany(p => p.OrderBomDetails)
                            .GroupBy(p => p.Item).ToDictionary(d => d.Key, d => d.Sum(q => q.OrderedQty));
                    }

                    string hql = @"select distinct(isnull(d.LocFrom,f.LocFrom)) from Scm_FlowDet as d 
                               join SCM_FlowMstr f on d.Flow = f.Code
                               where f.IsActive = ? and (d.LocTo =? or (d.LocTo is null and f.LocTo = ? ))
                               and d.Item in(?  ";
                    var locations = genericMgr.FindAllWithNativeSqlIn<string>
                        (hql, itemQtyDic.Select(p => p.Key), new object[] { true, orderMaster.LocationFrom, orderMaster.LocationFrom });

                    foreach (var location in locations)
                    {
                        if (sql == string.Empty)
                        {
                            sql = @" select l.* from VIEW_LocationDet as l with(nolock) where l.ATPQty>0 and l.Location in(?,? ";
                        }
                        else
                        {
                            sql += ",?";
                        }
                    }
                    paramList.AddRange(locations);
                }
                else
                {
                    TryLoadOrderDetails(orderMaster);
                    if (orderMaster.OrderDetails != null)
                    {
                        itemQtyDic = orderMaster.OrderDetails
                            .GroupBy(p => p.Item).ToDictionary(d => d.Key, d => d.Sum(q => q.OrderedQty));
                    }
                    sql = @" select l.* from VIEW_LocationDet as l with(nolock) where l.ATPQty>0 and (l.Location =? ";
                }
                sql += @" ) and l.Item in(? ";

                IList<LocationDetailView> locationDetailViewList = this.genericMgr.FindEntityWithNativeSqlIn<LocationDetailView>
                    (sql, itemQtyDic.Select(p => p.Key), paramList);

                var invDic = (from p in locationDetailViewList
                              group p by p.Item into g
                              select new
                              {
                                  Item = g.Key,
                                  Qty = g.Sum(q => q.ATPQty)
                              }).ToDictionary(d => d.Item, d => d.Qty);
                foreach (var itemQty in itemQtyDic)
                {
                    var diffQty = itemQty.Value - invDic.ValueOrDefault(itemQty.Key);
                    if (diffQty > 0)
                    {
                        ex.AddMessage(string.Format("物料:{0}[{1}]没有足够的库存,缺口:{2}",
                            itemQty.Key, itemMgr.GetCacheItem(itemQty.Key).FullDescription, diffQty.ToString("0.##")));
                    }
                }
            }
            if (ex.GetMessages() != null && ex.GetMessages().Count > 0)
            {
                throw ex;
            }
        }
        private void LoadHyphenationSettings()
        {
            var ssf = _settingsHelper.GetSettingsFilename(_settingsHelper.Database);
            if (ssf != null && ssf.Trim().Length > 0)
            {
	            if (AppDomain.CurrentDomain.FriendlyName.ToLower() == "paratext.exe")
	            {
		            var paratextpath = Path.Combine(Path.GetDirectoryName(ssf), _settingsHelper.Database);
		            Param.DatabaseName = _settingsHelper.Database;
		            Param.IsHyphen = false;
		            Param.HyphenLang = Common.ParaTextDcLanguage(_settingsHelper.Database, true);
		            foreach (string filename in Directory.GetFiles(paratextpath, "*.txt"))
		            {
			            if (filename.Contains("hyphen"))
			            {
				            Param.IsHyphen = true;
				            Param.HyphenFilepath = filename;
				            Param.HyphenationSelectedLanguagelist.AddRange(Param.HyphenLang.Split(','));
			            }
		            }
	            }
	            if (AppDomain.CurrentDomain.FriendlyName.ToLower().Contains("fieldworks"))
	            {
		            var xdoc = new XmlDocument();
		            try
		            {
						IDictionary<string,string> value=new Dictionary<string, string>();
						var settingsFile = ssf;
			            xdoc.Load(settingsFile);
			            var curVernWssnode = xdoc.SelectSingleNode("//CurVernWss/Uni");
			            if (curVernWssnode != null)
			            {
				            foreach (var lang in curVernWssnode.InnerText.Split(' '))
				            {
								var langname = GetLanguageValues(lang);
					            if (!string.IsNullOrEmpty(lang) && (langname != null) && !value.ContainsKey(lang))
						            value.Add(lang, langname.Replace(',',' '));
				            }
			            }
			            var curAnalysisWssnode = xdoc.SelectSingleNode("//CurAnalysisWss/Uni");
			            if (curAnalysisWssnode != null)
			            {
							foreach (var lang in curAnalysisWssnode.InnerText.Split(' '))
				            {
								var langname = GetLanguageValues(lang);
								if (!string.IsNullOrEmpty(lang) && (langname != null) && !value.ContainsKey(lang))
									value.Add(lang, langname.Replace(',', ' '));
				            }
			            }
						Param.HyphenLang = string.Join(",", value.Select(x => x.Key + ":" + x.Value).ToArray());
		            }
		            catch (Exception)
		            {
		            }
	            }

            }
			Common.EnableHyphenation();
            CreatingHyphenationSettings.ReadHyphenationSettings(_settingsHelper.Database, InputType);
            foreach (string lang in Param.HyphenLang.Split(','))
            {
                    clbHyphenlang.Items.Add(lang, (Param.HyphenationSelectedLanguagelist.Contains(lang) ? true : false));
            }
        }
Example #15
0
        private static void CreateTableForType(Type type, Type parent, Dictionary<string, Type> values, string embeddedPrefix = "")
        {
            // Save all scalar and inline types first, so we have the new entry id for our mn-table later
            foreach (var property in PersistentProperty.GetPersistentProperties(type, embeddedPrefix, parent))
            {
                if (property.IsSimpleType)
                {
                    // save array of basic types
                    if (property.Type.IsArray && property.ArrayCount != -1)
                    {
                        for (int i = 0; i < property.ArrayCount; i++)
                        {
                            values.Add(property.ColumnName + "_" + i, property.Property.PropertyType);
                        }
                    }
                    else
                    {
                        values.Add(property.ColumnName, property.Type);
                    }
                    continue;
                }

                if (property.IsGenericList || property.IsGenericDictionary)
                {
                    string query = "";

                    if (property.IsGenericList)
                    {
                        query = "CREATE TABLE {0} ({1}Id NUMERIC, {2}Id NUMERIC)";
                    }

                    if (property.IsGenericDictionary)
                    {
                        query = "CREATE TABLE {0} ({1}Id NUMERIC, {2}Id NUMERIC, Key TEXT)";
                    }

                    query = String.Format(query, property.RelationTableName, parent == null ? type.Name : parent.Name, property.ListType.Name);

                    using (var cmd = new SQLiteCommand(query, DBManager.MPQMirror))
                    {
                        cmd.ExecuteNonQuery();
                    }

                    CreateTableForType(property.ListType, null, new Dictionary<string, Type>());
                    continue;
                }

                values.Add(property.ColumnName + "_", typeof(string));
                CreateTableForType(property.Type, parent == null ? type : parent, values, property.ColumnName + "_");
            }

            // Only create tables for parent classes
            if (parent == null && !tableExists(type.Name))
            {
                if (type.Namespace == "System")
                {
                    values.Add("Value", typeof(string));
                }

                var columnDefinitions = values.Select(v => v.Key + " " + ((v.Value == typeof(String) || v.Value == typeof(byte[])) ? "TEXT" : "NUMERIC")).ToList<string>();
                columnDefinitions.Add("Id INTEGER PRIMARY KEY");
                var tableDefinition = String.Join(",", columnDefinitions.ToArray<string>());

                using (var cmd = new SQLiteCommand(String.Format("CREATE TABLE {0} ({1})", type.Name, tableDefinition), DBManager.MPQMirror))
                {
                    cmd.ExecuteNonQuery();
                }
            }
        }
Example #16
0
            //public static string GetNewInputId() //(string id = null)
            //{
            //    _storage.
            //    var service = EntryPointProxy.GetIOService();
            //    var req = new IOService.postDataRequest();
            //    req.DataID = null;//id;
            //    //req.CalcPackage = null;
            //    var resp = service.postData(req);
            //    return resp.DataId;
            //}
            private static string SendToStorageCore(string method, Dictionary<string, string> args)
            {
                string coreUrl = Config.AppSettings["Storage"];
                string coreToken = Config.AppSettings["StorageToken"];

                using (var webClient = new WebClient())
                {
                    webClient.BaseAddress = coreUrl;
                    webClient.Encoding = Encoding.UTF8; //.GetEncoding(1251);
                    webClient.Headers.Add("Content-Type", "application/json");

                    args["secid"] = coreToken;

                    string message = "{" + String.Join(", ", args.Select(pair => String.Format(@"""{0}"": ""{1}""", pair.Key, pair.Value))) + "}";
                    Log.Debug(String.Format("Sending to storage: {0} {1}", method, message));

                    string response = webClient.UploadString("", method, message);
                    Log.Debug("Storage response: " + response);

                    return response;
                }
            }
Example #17
0
 private static IEnumerable<KeyValuePair<string, ErrorsSummary>> _getPackSummary(
     Dictionary<string, PackClasterizedErrors> errorClassificationData,
     Func<PackClasterizedErrors, IEnumerable<IGrouping<int, ClasterizedSentenceError>>> errorsSelector)
 {
     return
         errorClassificationData.Select(
             pair =>
                 new KeyValuePair<string, ErrorsSummary>(pair.Key, _getTotalSummary(errorsSelector(pair.Value))));
 }
Example #18
0
        public static function_node DeduceFunction(function_node func, expressions_list fact, bool alone, location loc, List<SyntaxTree.expression> syntax_nodes_parameters = null)
        {
            parameter_list formal = func.parameters;
            int formal_count = formal.Count;
            int fact_count = fact.Count;
            int generic_type_params_count = func.generic_parameters_count;
            type_node[] deduced = new type_node[generic_type_params_count];
            List<int> nils = new List<int>();
            int count_params_to_see = fact_count;

            var lambda_syntax_nodes = new Dictionary<string, function_lambda_definition>(); //lroman Получим список фактических параметров-лямбд текущей вызываемой подпрограммы
            if (syntax_nodes_parameters != null
                && syntax_nodes_parameters.Count > 0) //lroman
            {
                lambda_syntax_nodes = syntax_nodes_parameters
                    .OfType<function_lambda_definition>()
                    .ToDictionary(f => f.lambda_name, f => f);
            }

            var lambda_in_parameters = lambda_syntax_nodes.Count > 0; 
            var saved_lambdas_states = SaveLambdasStates(lambda_syntax_nodes.Select(ld => ld.Value)); // Сохраним типы лямбды перед вычислениями

            if (fact_count < formal_count)
            {
                //Сравниваем количества параметров
                parameter par = formal[fact_count];
                if (par.default_value == null && !par.is_params)
                {
                    if (alone)
                        throw new NoFunctionWithSameParametresNum(loc, alone, func);
                    return null;
                }
            }
            else
            {
                type_node last_params_type = null;
                bool last_is_params = false;
                parameter par = null;
                if (formal_count > 0)
                {
                    par = formal[formal_count - 1];
                    last_is_params = par.is_params;
                }
                if (last_is_params)
                {
                    array_internal_interface aii = par.type.get_internal_interface(internal_interface_kind.unsized_array_interface) as array_internal_interface;
                    last_params_type = aii.element_type;
                }
                if (fact_count > formal_count)
                {
                    //Фактических больше, чем формальных. Последний формальный должен быть params...
                    if (last_is_params)
                    {
                        for (int i = formal_count - 1; i < fact_count; ++i)
                        {
                            //Проверяем фактические, попадающие под params...
                            if (!DeduceInstanceTypes(last_params_type, fact[i].type, deduced, nils))
                            {
                                if (alone)
                                    throw new SimpleSemanticError(loc, "GENERIC_FUNCTION_{0}_CAN_NOT_BE_CALLED_WITH_THESE_PARAMETERS", func.name);
                                return null;
                            }
                        }
                        count_params_to_see = formal_count - 1;
                    }
                    else
                    {
                        if (alone)
                            throw new NoFunctionWithSameParametresNum(loc, alone, func);
                        return null;
                    }
                }
            }
            bool need_params_work = (count_params_to_see > 0 && formal[count_params_to_see - 1].is_params);
            if (need_params_work)
            {
                count_params_to_see -= 1;
            }

            var continue_trying_to_infer_types = true; 
            Dictionary<string, delegate_internal_interface> formal_delegates = null; 

            while (continue_trying_to_infer_types) //Продолжаем пытаться вычислить типы до тех пор пока состояние о выведенных типах не будет отличаться от состояния на предыдущей итерации
            {
                var previous_deduce_state = deduced // Текущее состояние выведенных на данный момент типов. Простой список индексов с уже выведенными типами из массива deduced
                        .Select((t, i) => new { Type = t, Index = i })
                        .Where(t => t.Type != null)
                        .Select(t => t.Index)
                        .ToArray();

                for (int i = 0; i < count_params_to_see; ++i)
                {
                    if (!DeduceInstanceTypes(formal[i].type, fact[i].type, deduced, nils))
                    {
                        if (alone)
                            throw new SimpleSemanticError(loc, "GENERIC_FUNCTION_{0}_CAN_NOT_BE_CALLED_WITH_THESE_PARAMETERS", func.name);
                        RestoreLambdasStates(lambda_syntax_nodes.Values.ToList(), saved_lambdas_states);
                        return null;
                    }

                }

                if (lambda_in_parameters)
                {
                    if (formal_delegates == null)
                    {
                        formal_delegates = new Dictionary<string, delegate_internal_interface>();

                        for (int i = 0; i < count_params_to_see; ++i)
                            //Выделим из формальных параметров те, которые соотвтествуют фактическим параметрам-лямбдам
                        {
                            var lambda_func = fact[i].type as delegated_methods;
                            if (lambda_func != null
                                && lambda_func.proper_methods.Count == 1
                                && LambdaHelper.IsLambdaName(lambda_func.proper_methods[0].simple_function_node.name))
                            {
                                formal_delegates.Add(LambdaHelper.GetLambdaNamePartWithoutGenerics(lambda_func.proper_methods[0].simple_function_node.name),
                                                     formal[i].type.get_internal_interface(
                                                         internal_interface_kind.delegate_interface) as
                                                     delegate_internal_interface);
                            }
                        }
                    }

                    foreach (var formal_delegate in formal_delegates)
                        //Перебираем все полученные формальные параемтры, соотвтетсвующие фактическим лямбдам
                    {
                        var lambda_syntax_node = lambda_syntax_nodes[formal_delegate.Key];
                        Exception on_lambda_body_compile_exception;
                            // Исключение которое может возникунть в результате компиляции тела лямбды если мы выберем неправильные типы параметров
                        if (!TryToDeduceTypesInLambda(lambda_syntax_node, formal_delegate.Value, deduced, nils,
                                                      out on_lambda_body_compile_exception))
                            //Пробуем вычислить типы из лямбд
                        {
                            RestoreLambdasStates(lambda_syntax_nodes.Values.ToList(), saved_lambdas_states);

                            if (on_lambda_body_compile_exception != null)
                            {
                                if (alone)
                                {
                                    throw on_lambda_body_compile_exception;
                                }

                                throw new FailedWhileTryingToCompileLambdaBodyWithGivenParametersException(
                                    on_lambda_body_compile_exception);
                            }

                            if (alone)
                            {
                                throw new SimpleSemanticError(loc, "GENERIC_FUNCTION_{0}_CAN_NOT_BE_CALLED_WITH_THESE_PARAMETERS", func.name);
                            }
                            return null;
                        }
                    }
                }
                var current_deduce_state = deduced               //текущее состояние выведенных типов
                    .Select((t, ii) => new {Type = t, Index = ii})
                    .Where(t => t.Type != null)
                    .Select(t => t.Index)
                    .ToArray();

                if (previous_deduce_state.SequenceEqual(current_deduce_state)) // Если ничего с прошлой итерации не изменилось, то дальше нет смысла пробовать выводить. Выходим из цикла
                {
                    continue_trying_to_infer_types = false;
                }
            }

            RestoreLambdasStates(lambda_syntax_nodes.Values.ToList(), saved_lambdas_states);

            if (need_params_work)
            {
                type_node[] tmp_deduced = (type_node[])deduced.Clone();
                List<int> tmp_nils = new List<int>();
                tmp_nils.AddRange(nils);
                if (!DeduceInstanceTypes(formal[count_params_to_see].type, fact[count_params_to_see].type, deduced, nils))
                {
                    //Второй шанс. Учитываем слово params.
                    deduced = tmp_deduced;
                    nils = tmp_nils;
                    if (!DeduceInstanceTypes(formal[count_params_to_see].type.element_type, fact[count_params_to_see].type, deduced, nils))
                    {
                        if (alone)
                            throw new SimpleSemanticError(loc, "GENERIC_FUNCTION_{0}_CAN_NOT_BE_CALLED_WITH_THESE_PARAMETERS", func.name);
                        return null;
                    }
                }
            }
            //Вывели всё, что могли. Теперь проверяем.
            for (int i = 0; i < generic_type_params_count; ++i)
            {
                if (deduced[i] == null)
                {
                    if (alone)
                        throw new SimpleSemanticError(loc, "CAN_NOT_DEDUCE_TYPE_PARAMS_FROM_CALL_{0}", func.name);
                    return null;
                }
            }
            foreach (int num in nils)
            {
                if (!type_table.is_with_nil_allowed(deduced[num]))
                {
                    if (alone)
                        throw new SimpleSemanticError(loc, "GENERIC_FUNCTION_{0}_CAN_NOT_BE_CALLED_WITH_THESE_PARAMETERS", func.name);
                    return null;
                }
            }
            foreach (type_node tt in deduced)
            {
                CompilationErrorWithLocation check_err = generic_parameter_eliminations.check_type_generic_useful(tt, loc);
                if (check_err != null)
                {
                    if (alone)
                        throw check_err;
                    return null;
                }
            }
            //Итак, вывели все параметры. Теперь инстанцируем.
            List<type_node> deduced_list = new List<type_node>(generic_type_params_count);
            deduced_list.AddRange(deduced);
            return func.get_instance(deduced_list, alone, loc);
        }
Example #19
0
        private string BuildDescriptorDeclaration(FieldDescriptorProto field, bool emitFieldLabel = true)
        {
            PushDescriptorName(field);

            string type = ResolveType(field);
            Dictionary<string, string> options = new Dictionary<string, string>();

            if (!String.IsNullOrEmpty(field.default_value))
            {
                string default_value = field.default_value;

                if (field.type == FieldDescriptorProto.Type.TYPE_STRING)
                    default_value = String.Format("\"{0}\"", default_value);

                options.Add("default", default_value);
            }
            else if (field.type == FieldDescriptorProto.Type.TYPE_ENUM && field.label != FieldDescriptorProto.Label.LABEL_REPEATED)
            {
                options.Add("default", ResolveOrDeferEnumDefaultValue(type));
            }

            Dictionary<string, string> fieldOptions = DumpOptions(field.options);
            foreach (var pair in fieldOptions)
            {
                options[pair.Key] = pair.Value;
            }

            string parameters = String.Empty;
            if (options.Count > 0)
            {
                parameters = " [" + String.Join(", ", options.Select(kvp => String.Format("{0} = {1}", kvp.Key, kvp.Value))) + "]";
            }

            PopDescriptorName();

            var descriptorDeclarationBuilder = new StringBuilder();
            if (emitFieldLabel)
            {
                descriptorDeclarationBuilder.Append(GetLabel(field.label));
                descriptorDeclarationBuilder.Append(" ");
            }

            descriptorDeclarationBuilder.AppendFormat("{0} {1} = {2}{3};", type, field.name, field.number, parameters);

            return descriptorDeclarationBuilder.ToString();
        }
Example #20
0
        //REMOVER
        private string generateJson(Dictionary<string, string> fields)
        {
            var entries = fields.Select(d =>
                string.Format("\"{0}\":\"{1}\"", d.Key, string.Join(",", d.Value)));
            string json = "{" + string.Join(",", entries) + "}";

            return json;
        }
Example #21
0
        public void Build(string text)
        {
            if (text == null)
            {
                throw new ArgumentNullException("text");
            }

            this._Root = null;
            var frequencies = new Dictionary<char, int>();
            this._Codes.Clear();

            foreach (var t in text)
            {
                int frequency;
                if (frequencies.TryGetValue(t, out frequency) == false)
                {
                    frequency = 0;
                }
                frequencies[t] = frequency + 1;
            }

            var nodes = frequencies.Select(
                symbol => new Node()
                {
                    Symbol = symbol.Key,
                    Frequency = symbol.Value,
                }).ToList();

            while (nodes.Count > 1)
            {
                var orderedNodes = nodes
                    .OrderBy(n => n.Frequency).ToList();

                if (orderedNodes.Count >= 2)
                {
                    var taken = orderedNodes.Take(2).ToArray();
                    var first = taken[0];
                    var second = taken[1];

                    var parent = new Node()
                    {
                        Symbol = '\0',
                        Frequency = first.Frequency + second.Frequency,
                        Left = first,
                        Right = second,
                    };

                    nodes.Remove(first);
                    nodes.Remove(second);
                    nodes.Add(parent);
                }

                this._Root = nodes.FirstOrDefault();
            }

            foreach (var frequency in frequencies)
            {
                var bits = Traverse(this._Root, frequency.Key, new List<bool>());
                if (bits == null)
                {
                    throw new InvalidOperationException(string.Format(
                        "could not traverse '{0}'", frequency.Key));
                }
                this._Codes.Add(frequency.Key, new BitArray(bits.ToArray()));
            }

            this.TotalBits = GetTotalBits(this._Root);
        }
        /// <summary>
        /// Determines the expected shape of store results. We expect a column for every property
        /// of the mapped type (or types) and a column for every discriminator column. We make no
        /// assumptions about the order of columns: the provider is expected to determine appropriate
        /// types by looking at the names of the result columns, not the order of columns, which is
        /// different from the typical handling of row types in the EF.
        /// </summary>
        /// <remarks>
        /// Requires that the given function import mapping refers to a Collection(Entity) or Collection(ComplexType) CSDL
        /// function.
        /// </remarks>
        /// <returns>Row type.</returns>
        internal TypeUsage GetExpectedTargetResultType(int resultSetIndex)
        {
            var resultMapping = GetResultMapping(resultSetIndex);

            // Collect all columns as name-type pairs.
            var columns = new Dictionary<string, TypeUsage>();

            // Figure out which entity types we expect to yield from the function.
            IEnumerable<StructuralType> structuralTypes;
            if (0 == resultMapping.NormalizedEntityTypeMappings.Count)
            {
                // No explicit type mappings; just use the type specified in the ReturnType attribute on the function.
                StructuralType structuralType;
                MetadataHelper.TryGetFunctionImportReturnType(FunctionImport, resultSetIndex, out structuralType);
                Debug.Assert(null != structuralType, "this method must be called only for entity/complextype reader function imports");
                structuralTypes = new[] { structuralType };
            }
            else
            {
                // Types are explicitly mapped.
                structuralTypes = resultMapping.MappedEntityTypes.Cast<StructuralType>();
            }

            // Gather columns corresponding to all properties.
            foreach (var structuralType in structuralTypes)
            {
                foreach (EdmProperty property in TypeHelpers.GetAllStructuralMembers(structuralType))
                {
                    // NOTE: if a complex type is encountered, the column map generator will
                    // throw. For now, we just let them through.

                    // We expect to see each property multiple times, so we use indexer rather than
                    // .Add.
                    columns[property.Name] = property.TypeUsage;
                }
            }

            // Gather discriminator columns.
            foreach (var discriminatorColumn in GetDiscriminatorColumns(resultSetIndex))
            {
                if (!columns.ContainsKey(discriminatorColumn))
                {
                    // CONSIDER: we assume that discriminatorColumns are all string types. In practice,
                    // we're flexible about the runtime type during materialization, so the provider's
                    // decision is hopefully irrelevant. The alternative is to require typed stored
                    // procedure declarations in the SSDL, which is too much of a burden on the user and/or the
                    // tools (there is no reliable way of determining this metadata automatically from SQL
                    // Server).

                    var type = TypeUsage.CreateStringTypeUsage(
                        MetadataWorkspace.GetModelPrimitiveType(PrimitiveTypeKind.String), true, false);
                    columns.Add(discriminatorColumn, type);
                }
            }

            // Expected type is a collection of rows
            var rowType = new RowType(columns.Select(c => new EdmProperty(c.Key, c.Value)));
            var result = TypeUsage.Create(new CollectionType(TypeUsage.Create(rowType)));
            return result;
        }
 private string SerializeDictionary(Dictionary<string, object> obj)
 {
     return string.Format ("{{{0}}}", string.Join (",", obj.Select (kvp => string.
         Format ("{0}:{1}", SerializeString (kvp.Key), Serialize(kvp.Value)))));
 }
		private static void RemoveTemporaryMembers(Dictionary<string, string> source)
		{
			var sourceNames = source.Select(x => x.Key).ToArray();

			if (!_temporaryMemberNames.All(x => sourceNames.Contains(x)))
				return;

			foreach (var name in _temporaryMemberNames)
				source.Remove(name);
		}
Example #25
0
 /// <summary>
 ///     Gets the clients by identifier.
 /// </summary>
 /// <param name="users">The users.</param>
 /// <returns>IEnumerable&lt;GameClient&gt;.</returns>
 internal IEnumerable<GameClient> GetClientsById(Dictionary<uint, MessengerBuddy>.KeyCollection users)
     => users.Select(GetClientByUserId).Where(clientByUserId => clientByUserId != null);
        /// <summary>
        /// Determines the expected shape of store results. We expect a column for every property
        /// of the mapped type (or types) and a column for every discriminator column. We make no
        /// assumptions about the order of columns: the provider is expected to determine appropriate
        /// types by looking at the names of the result columns, not the order of columns, which is
        /// different from the typical handling of row types in the EF.
        /// </summary>
        /// <remarks>
        /// Requires that the given function import mapping refers to a Collection(Entity) or Collection(ComplexType) CSDL
        /// function.
        /// </remarks>
        /// <returns>Row type.</returns>
        internal TypeUsage GetExpectedTargetResultType(MetadataWorkspace workspace, int resultSetIndex)
        {
            FunctionImportStructuralTypeMappingKB resultMapping = this.GetResultMapping(resultSetIndex);
            
            // Collect all columns as name-type pairs.
            Dictionary<string, TypeUsage> columns = new Dictionary<string, TypeUsage>();

            // Figure out which entity types we expect to yield from the function.
            IEnumerable<StructuralType> structuralTypes;
            if (0 == resultMapping.NormalizedEntityTypeMappings.Count)
            {
                // No explicit type mappings; just use the type specified in the ReturnType attribute on the function.
                StructuralType structuralType;
                MetadataHelper.TryGetFunctionImportReturnType<StructuralType>(this.FunctionImport, resultSetIndex, out structuralType);
                Debug.Assert(null != structuralType, "this method must be called only for entity/complextype reader function imports");
                structuralTypes = new StructuralType[] { structuralType };
            }
            else
            {
                // Types are explicitly mapped.
                structuralTypes = resultMapping.MappedEntityTypes.Cast<StructuralType>();
            }

            // Gather columns corresponding to all properties.
            foreach (StructuralType structuralType in structuralTypes)
            {
                foreach (EdmProperty property in TypeHelpers.GetAllStructuralMembers(structuralType))
                {
                    // NOTE: if a complex type is encountered, the column map generator will
                    // throw. For now, we just let them through.

                    // We expect to see each property multiple times, so we use indexer rather than
                    // .Add.
                    columns[property.Name] = property.TypeUsage;
                }
            }

            // Gather discriminator columns.
            foreach (string discriminatorColumn in this.GetDiscriminatorColumns(resultSetIndex))
            {
                if (!columns.ContainsKey(discriminatorColumn))
                {
                    // 






                    TypeUsage type = TypeUsage.CreateStringTypeUsage(workspace.GetModelPrimitiveType(PrimitiveTypeKind.String), true, false);
                    columns.Add(discriminatorColumn, type);
                }
            }

            // Expected type is a collection of rows
            RowType rowType = new RowType(columns.Select(c => new EdmProperty(c.Key, c.Value)));
            TypeUsage result = TypeUsage.Create(new CollectionType(TypeUsage.Create(rowType)));
            return result;
        }
        /// <summary>
        /// Returns all the resource strings for all cultures for a specific resource Id.
        /// Returned as a dictionary.
        /// </summary>
        /// <param name="resourceId">Resource Id to retrieve strings for</param>
        /// <param name="resourceSet">Resource Set on which to retrieve strings</param>
        /// <param name="forAllResourceSetLocales">If true returns empty entries for each locale that exists but has no value in this resource set</param>
        /// <returns></returns>
        public virtual Dictionary<string, string> GetResourceStrings(string resourceId, string resourceSet, bool forAllResourceSetLocales = false)
        {
            var Resources = new Dictionary<string, string>();
            using (var data = GetDb())
            {
                using (DbDataReader reader = data.ExecuteReader("select Value,LocaleId from " + Configuration.ResourceTableName +
                                                                " where [email protected] and [email protected] order by LocaleId",
                    data.CreateParameter("@ResourceId", resourceId),
                    data.CreateParameter("@ResourceSet", resourceSet)))
                {
                    if (reader == null)
                        return null;

                    while (reader.Read())
                    {
                        Resources.Add(reader["LocaleId"] as string, reader["Value"] as string);
                    }
                    reader.Dispose();
                }

                if (forAllResourceSetLocales)
                {
                    var locales = GetAllLocalesForResourceSet(resourceSet);
                    if (locales != null)
                    {
                        var usedLocales = Resources.Select(kv => kv.Key);
                        var emptyLocales = locales.Where(s => !usedLocales.Contains(s));
                        foreach (var locale in emptyLocales)
                        {
                            Resources.Add(locale, "");
                        }
                    }
                }

            }

            

            return Resources;
        }
 private ArrayList TypeForCategoryJsonArray(string Category)
 {            
     ArrayList typeList = new ArrayList();
     dictionaryItem = TestTypes.TypeWithSecureFlag(Category);
     isSecuredFlag = dictionaryItem != null && dictionaryItem.Where(x => Boolean.Parse(x.Value.ToString())).Select(y => y.Key).ToList().Distinct().Any();
     if (dictionaryItem != null && dictionaryItem.Select(c => c.Key).Any())
     {
         if (isSecuredFlag && UserHasPermission(Permission.Access_SecureTesting))
         {
             typeList.Add(new object[] { dictionaryItem.Select(c => c.Key).ToArray() });
         }
         else
         {
             typeList.Add(new object[] { dictionaryItem.Where(c => !c.Value).Select(c => c.Key).ToArray() });
         }
         
     }
     return typeList;
 }
 public static MapRepresentation CreateMap(Dictionary<string, object> exts) {
     OptionalProperty[] parms = exts.Select(e => new OptionalProperty(e.Key, e.Value)).ToArray();
     return MapRepresentation.Create(parms);
 }
Example #30
0
        public virtual void EvolveTimingChromosome(LearningMode learningMode, Dictionary<BitArray,double> agents,
            double crossOverProbability, double mutationProbability)
        {
            switch (learningMode)
            {
                case LearningMode.Random:
                    RandomizeTimingChromosome(_random);
                    break;
                case LearningMode.GA:
                    if (_random.NextDouble() < crossOverProbability)
                    {
                        //selection
                        var chromosomes =
                            agents.Select(a => new {a.Key, Rank = a.Value*_random.NextDouble()});

                        var chosenChromosome = chromosomes.OrderByDescending(c => c.Rank).First();

                        //crossover

                        var crossOver = Math.Floor(_random.NextDouble()*TimingChromosome.Count);

                        for (int i = 0; i < crossOver; i++)
                        {
                            TimingChromosome[i] = chosenChromosome.Key[i];
                        }
                    }

                    //mutation
                    for (int i = 0; i < TimingChromosome.Count; i++)
                    {
                        TimingChromosome[i] = _random.NextDouble() < mutationProbability
                            ? !TimingChromosome[i]
                            : TimingChromosome[i];
                    }
                    break;

                case LearningMode.MRE:
                    //update propensities
                    for (int i = 0; i < _learningLog.Count; i++)
                    {
                        double reward;

                        if (_learningLog[i].TimingChromosome == TimingChromosome)
                        {
                            reward = CurrentProfit*(1 - _experimentation);
                        }
                        else
                        {
                            reward = _learningLog[i].Propensity * (_experimentation / (_learningLog.Count -1));
                        }

                        _learningLog[i].Propensity = (1 - _recency)*_learningLog[i].Propensity + reward;
                    }

                    //update probabilities
                    for (int i = 0; i < _learningLog.Count; i++)
                    {
                        _learningLog[i].Probability = Math.Exp(_learningLog[i].Propensity/_temperature)/
                                                      _learningLog.Sum(l => Math.Exp(l.Propensity/_temperature));
                    }

                    //select chromosome
                    TimingChromosome = _learningLog.OrderByDescending(l => l.Probability * _random.NextDouble()).First().TimingChromosome;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Unknown learning mode");
            }

            CurrentProfit = 0;
        }