public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer) { var values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); // Get the value for each member in the dynamic object var clay = obj as IClayBehaviorProvider; clay.Behavior.GetMembers(() => null, clay, values); return values.ToDictionary(kv => kv.Key, kv => (object)((dynamic)kv.Value).Get()); }
private IDictionary<string, object> ExecuteInsertCommand(IDbCommand command, Dictionary<string, FbParameter> columnParameters, bool resultRequired) { command.ExecuteNonQuery(); if (resultRequired) { return columnParameters.ToDictionary(p => p.Key, p => p.Value.Value is DBNull ? null : p.Value.Value); } return null; }
public frmProject(SPWrapper sp) { Check.ArgNull (sp, "sp"); this.sp = sp; InitializeComponent(); configToFields = new Dictionary<string, Setting> { //BOTH {"id", new TextSetting (inID)}, {"display_name", new TextSetting (inDisplayName)}, {"authorization_key", new TextSetting (inAuthKey)}, {"version", new TextSetting (inVersion)}, {"loading_screen_file", new TextSetting (inLoading)}, {"url_schemes", new TextSetting (inURLSchemes)}, {"orientations", new ComboSetting<Orientation> (cmbOrientation, OrientationSerialize.fromOrientation, OrientationSerialize.toOrientation)}, // IOS //{"ios_device_families", new ComboSetting (cmbDeviceFamily)}, {"ios_resources", new FileSetting (fileResourcesiOS)}, {"ios_dev_identity", new FileSetting (fileIdentity)}, {"ios_add_icon_gloss", new BoolSetting (inGlassEffect)}, {"ios_dev_mobile_provision_file", new FileSetting (fileProvision)}, {"ios_app_runs_in_background", new BoolSetting (inBackground)}, {"ios_device_families", new ComboSetting<DeviceFamily> (cmbFamiliesiOS, FamilySerialize.fromFamily, FamilySerialize.toFamily)}, // ANDROID {"version_code", new TextSetting (inVersionAndroid)}, {"keystore_file", new FileSetting (fileKeystore)}, {"keystore_password_file",new FileSetting (fileKeystorePassword)}, {"key_password_file", new FileSetting (fileKeyPassword)}, {"android_resources", new FileSetting (fileResourcesAndroid)} }; fieldsToConfig = configToFields.ToDictionary (p => p.Value, p => p.Key); }
public static void Register(Type[] regTypes) { if (!s_initialized) throw new InvalidOperationException("NetSerializer not initialized"); var ctypes = CollectTypes(regTypes); var types = ctypes.Select(v => v).Where(v => !s_typeMap.ContainsKey(v)).ToArray<Type>(); #if GENERATE_DEBUGGING_ASSEMBLY GenerateAssembly(types, s_typeMap); #endif s_typeMap = GenerateDynamic(types, s_typeMap); s_typeID_TypeData = s_typeMap.ToDictionary(kvp => kvp.Value.TypeID, kvp => kvp.Value); #if GENERATE_SWITCH s_Type_caseIDtypeIDMap = s_typeMap.ToDictionary(kvp => kvp.Key, kvp => (uint)(kvp.Value.TypeID | (kvp.Value.CaseID << 16))); s_caseID_typeIDMap = s_typeMap.ToDictionary(kvp => kvp.Value.TypeID, kvp => kvp.Value.CaseID); #endif }
public static void Initialize(Type[] rootTypes) { if (s_initialized) throw new InvalidOperationException("NetSerializer already initialized"); var types = CollectTypes(rootTypes); #if GENERATE_DEBUGGING_ASSEMBLY GenerateAssembly(types, s_typeMap); #endif s_typeMap = GenerateDynamic(types, s_typeMap); s_typeID_TypeData = s_typeMap.ToDictionary(kvp => kvp.Value.TypeID, kvp => kvp.Value); #if GENERATE_SWITCH s_Type_caseIDtypeIDMap = s_typeMap.ToDictionary(kvp => kvp.Key, kvp => (uint)(kvp.Value.TypeID | (kvp.Value.CaseID << 16))); s_caseID_typeIDMap = s_typeMap.ToDictionary(kvp => kvp.Value.TypeID, kvp => kvp.Value.CaseID); #endif s_initialized = true; }
private void ButtonConsolidateOutputFiles_Click(object sender, RoutedEventArgs e) { var writeEachConceptFeature = CheckBoxExtractTextFeaturesEachTweet.IsChecked.Value; var concepteaturesOutputTableName = TextBoxConceptFeatures.Text; var conceptFeaturesOutputTable = database.GetCollection<BsonDocument>(concepteaturesOutputTableName); var imagesFolder = TextBoxImagesFilesFolder.Text; var filesInDir = Directory.GetFiles(imagesFolder, "*.txt"); var normaliseFeatures = CheckBoxNormaliseFeatures.IsChecked.Value; Task.Run(() => { var filesProcessed = 0; foreach (var file in filesInDir) { try { var imageId = Path.GetFileNameWithoutExtension(file); if (imageId == tweetsPathFileName) continue; var userRecordValues = File.ReadAllText(file) .Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries); var concepts = userRecordValues.Select(userRecordValue => float.Parse(userRecordValue, CultureInfo.InvariantCulture)).ToList(); if (featureSetSize != concepts.Count) { Write("Inconsistent features set size: " + concepts.Count + " " + imageId); continue; } var twitterId = mediaTable.FindOne(Query.EQ("_id", imageId))["twitter_id"].AsString; if (!usersScores.Contains(twitterId)) { usersScores.Add(twitterId, new Dictionary<string, List<float>>()); } usersScores[twitterId].Add(imageId, concepts); } catch (Exception exc) { Write(exc.ToString()); } filesProcessed++; if (filesProcessed % 1000 == 0) { Write("File processed: " + filesProcessed); } } var min = double.MaxValue; var max = double.MinValue; foreach (var userScore in usersScores) { foreach (var scoreList in userScore.Value) { foreach (var score in scoreList.Value) { if (score < min) min = score; if (score > max) max = score; } } } double range; double topUp; if (Math.Sign(max) == Math.Sign(min)) { range = Math.Abs(max) - Math.Abs(min); topUp = - Math.Abs(min); } else { range = Math.Abs(max) + Math.Abs(min); topUp = Math.Abs(min); } Write("Max: " + max); Write("Min: " + min); Write("Range: " + range); Write("Topup: " + topUp); foreach (var userScore in usersScores) { if (writeEachConceptFeature) { foreach (var scoreList in userScore.Value) { var conceptFeaturesDoc = new BsonDocument { {"_id", scoreList.Key}, {"concepts", new BsonArray(scoreList.Value)} }; conceptFeaturesOutputTable.Insert(conceptFeaturesDoc); } } else { if (conceptFeaturesOutputTable.FindOne(Query.EQ("_id", userScore.Key)) != null) continue; var probabilities = new Dictionary<int, double>(); var numberOfPicturesTaken = userScore.Value.Count; var conceptFeaturesDoc = new BsonDocument { {"_id", userScore.Key}, {"numberOfImages", numberOfPicturesTaken} }; foreach (var scoreList in userScore.Value) { var counter = 0; foreach (var score in scoreList.Value) { counter++; var probability = (score + topUp)/range; if (!probabilities.ContainsKey(counter)) { probabilities.Add(counter, 0); } if (binaryFeatures) { probabilities[counter] += probability > treshhold ? 1 : 0; } else { probabilities[counter] += probability; } } } if (!normaliseFeatures) { numberOfPicturesTaken = 1; } var record = probabilities.ToDictionary(probability => probability.Key.ToString(CultureInfo.InvariantCulture), probability => probability.Value/numberOfPicturesTaken); conceptFeaturesDoc.AddRange(record); conceptFeaturesOutputTable.Insert(conceptFeaturesDoc); } } }); }
/// <summary> /// Save pre-selection forest. /// </summary> /// <param name="decisionForest">The forest with each tree corresponding to a unit.</param> /// <param name="candidateGroups">The candidate group collection.</param> /// <param name="unitCandidateNameIds">Given candidate idx.</param> /// <param name="customFeatures">Cusotmized linguistic feature list.</param> /// <param name="outputPath">The output path.</param> public void Write(DecisionForest decisionForest, ICollection<CandidateGroup> candidateGroups, IDictionary<string, int> unitCandidateNameIds, HashSet<string> customFeatures, string outputPath) { foreach (Question question in decisionForest.QuestionList) { question.Language = _phoneSet.Language; question.ValueSetToCodeValueSet(_posSet, _phoneSet, customFeatures); } FileStream file = new FileStream(outputPath, FileMode.Create); try { using (DataWriter writer = new DataWriter(file)) { file = null; uint position = 0; // Write header section place holder PreselectionFileHeader header = new PreselectionFileHeader(); position += (uint)header.Write(writer); HtsFontSerializer serializer = new HtsFontSerializer(); // Write feature, question and prepare string pool HtsQuestionSet questionSet = new HtsQuestionSet { Items = decisionForest.QuestionList, Header = new HtsQuestionSetHeader { HasQuestionName = false }, CustomFeatures = customFeatures, }; using (StringPool stringPool = new StringPool()) { Dictionary<string, uint> questionIndexes = new Dictionary<string, uint>(); header.QuestionOffset = position; header.QuestionSize = serializer.Write( questionSet, writer, stringPool, questionIndexes, customFeatures); position += header.QuestionSize; // Write leaf referenced data to buffer IEnumerable<INodeData> dataNodes = GetCandidateNodes(candidateGroups); using (MemoryStream candidateSetBuffer = new MemoryStream()) { Dictionary<string, int> namedSetOffset = new Dictionary<string, int>(); int candidateSetSize = HtsFontSerializer.Write( dataNodes, new DataWriter(candidateSetBuffer), namedSetOffset); // Write decision forest Dictionary<string, uint[]> namedOffsets = namedSetOffset.ToDictionary(p => p.Key, p => new[] { (uint)p.Value }); header.DecisionTreeSectionOffset = position; header.DecisionTreeSectionSize = (uint)Write(decisionForest, unitCandidateNameIds, questionIndexes, questionSet, namedOffsets, new DecisionForestSerializer(), writer); position += header.DecisionTreeSectionSize; // Write string pool header.StringPoolOffset = position; header.StringPoolSize = HtsFontSerializer.Write(stringPool, writer); position += header.StringPoolSize; // Write leaf referenced data header.CandidateSetSectionOffset = position; header.CandidateSetSectionSize = writer.Write(candidateSetBuffer.ToArray()); position += header.CandidateSetSectionSize; } // Write header section place holder using (PositionRecover recover = new PositionRecover(writer, 0)) { header.Write(writer); } } } } finally { if (null != file) { file.Dispose(); } } }
private ParamPack(string name, Dictionary<string, string> parameters) { Name = name; _parameters = parameters.ToDictionary(kv => kv.Key, kv => kv.Value); }
MyRenderMeshInfo LoadMesh(string assetName, out MyLODDescriptor[] LodDescriptors) { //Debug.Assert(assetName.EndsWith(".mwm")); #region Temporary for mwm endings if (!assetName.EndsWith(".mwm")) { assetName += ".mwm"; } #endregion var meshVertexInput = MyVertexInputLayout.Empty; LodDescriptors = null; MyRenderMeshInfo result = new MyRenderMeshInfo(); var importer = new MyModelImporter(); var fsPath = Path.IsPathRooted(assetName) ? assetName : Path.Combine(MyFileSystem.ContentPath, assetName); if (!MyFileSystem.FileExists(fsPath)) { System.Diagnostics.Debug.Fail("Model " + assetName + " does not exists!"); return MyAssetsLoader.GetDebugMesh().LODs[0].m_meshInfo; } string contentPath = null; if (Path.IsPathRooted(assetName) && assetName.ToLower().Contains("models")) contentPath = assetName.Substring(0, assetName.ToLower().IndexOf("models")); try { importer.ImportData(fsPath, new string[] { MyImporterConstants.TAG_VERTICES, MyImporterConstants.TAG_BLENDINDICES, MyImporterConstants.TAG_BLENDWEIGHTS, MyImporterConstants.TAG_NORMALS, MyImporterConstants.TAG_TEXCOORDS0, MyImporterConstants.TAG_TANGENTS, MyImporterConstants.TAG_BINORMALS, MyImporterConstants.TAG_BONES, MyImporterConstants.TAG_MESH_PARTS, MyImporterConstants.TAG_BOUNDING_BOX, MyImporterConstants.TAG_BOUNDING_SPHERE, MyImporterConstants.TAG_LODS, }); Dictionary<string, object> tagData = importer.GetTagData(); // extract data var positions = (HalfVector4[])tagData[MyImporterConstants.TAG_VERTICES]; System.Diagnostics.Debug.Assert(positions.Length > 0); var verticesNum = positions.Length; var boneIndices = (Vector4I[])tagData[MyImporterConstants.TAG_BLENDINDICES]; var boneWeights = (Vector4[])tagData[MyImporterConstants.TAG_BLENDWEIGHTS]; var normals = (Byte4[])tagData[MyImporterConstants.TAG_NORMALS]; var texcoords = (HalfVector2[])tagData[MyImporterConstants.TAG_TEXCOORDS0]; var tangents = (Byte4[])tagData[MyImporterConstants.TAG_TANGENTS]; var bintangents = (Byte4[])tagData[MyImporterConstants.TAG_BINORMALS]; var tangentBitanSgn = new Byte4[verticesNum]; for (int i = 0; i < verticesNum; i++) { var N = VF_Packer.UnpackNormal(normals[i].PackedValue); var T = VF_Packer.UnpackNormal(tangents[i].PackedValue); var B = VF_Packer.UnpackNormal(bintangents[i].PackedValue); var tanW = new Vector4(T.X, T.Y, T.Z, 0); tanW.W = T.Cross(N).Dot(B) < 0 ? -1 : 1; tangentBitanSgn[i] = VF_Packer.PackTangentSignB4(ref tanW); } bool hasBonesInfo = boneIndices.Length > 0 && boneWeights.Length > 0; var bones = (MyModelBone[])tagData[MyImporterConstants.TAG_BONES]; // var vertexBuffers = new List<IVertexBuffer>(); IIndexBuffer indexBuffer = null; var submeshes = new Dictionary<MyMeshDrawTechnique, List<MyDrawSubmesh>>(); var submeshes2 = new Dictionary<MyMeshDrawTechnique, List<MySubmeshInfo>>(); var submeshesMeta = new List<MySubmeshInfo>(); int indicesNum = 0; bool missingMaterial = false; if (tagData.ContainsKey(MyImporterConstants.TAG_MESH_PARTS)) { var indices = new List<uint>(positions.Length); uint maxIndex = 0; var meshParts = tagData[MyImporterConstants.TAG_MESH_PARTS] as List<MyMeshPartInfo>; foreach (MyMeshPartInfo meshPart in meshParts) { # region Bones indirection int[] bonesRemapping = null; if (boneIndices.Length > 0 && bones.Length > MyRender11Constants.SHADER_MAX_BONES) { Dictionary<int, int> vertexChanged = new Dictionary<int, int>(); Dictionary<int, int> bonesUsed = new Dictionary<int, int>(); int trianglesNum = meshPart.m_indices.Count / 3; for (int i = 0; i < trianglesNum; i++) { for (int j = 0; j < 3; j++) { int index = meshPart.m_indices[i * 3 + j]; if (boneWeights[index].X > 0) bonesUsed[boneIndices[index].X] = 1; if (boneWeights[index].Y > 0) bonesUsed[boneIndices[index].Y] = 1; if (boneWeights[index].Z > 0) bonesUsed[boneIndices[index].Z] = 1; if (boneWeights[index].W > 0) bonesUsed[boneIndices[index].W] = 1; } } if (bonesUsed.Count > MyRender11Constants.SHADER_MAX_BONES) { Debug.Assert(bonesUsed.Count <= MyRender11Constants.SHADER_MAX_BONES, "Model \"" + assetName + "\"'s part uses more than 60 bones, please split model on more parts"); } var partBones = new List<int>(bonesUsed.Keys); partBones.Sort(); if (partBones.Count > 0 && partBones[partBones.Count - 1] >= MyRender11Constants.SHADER_MAX_BONES) { for (int i = 0; i < partBones.Count; i++) { bonesUsed[partBones[i]] = i; } Dictionary<int, int> vertexTouched = new Dictionary<int, int>(); for (int i = 0; i < trianglesNum; i++) { for (int j = 0; j < 3; j++) { int index = meshPart.m_indices[i * 3 + j]; if (!vertexTouched.ContainsKey(index)) { if (boneWeights[index].X > 0) boneIndices[index].X = bonesUsed[boneIndices[index].X]; if (boneWeights[index].Y > 0) boneIndices[index].Y = bonesUsed[boneIndices[index].Y]; if (boneWeights[index].Z > 0) boneIndices[index].Z = bonesUsed[boneIndices[index].Z]; if (boneWeights[index].W > 0) boneIndices[index].W = bonesUsed[boneIndices[index].W]; vertexTouched[index] = 1; int changes = 0; vertexChanged.TryGetValue(index, out changes); vertexChanged[index] = changes + 1; } } } bonesRemapping = partBones.ToArray(); } if (vertexChanged.Values.Count > 0) Debug.Assert(vertexChanged.Values.Max() < 2, "Vertex shared between model parts, will likely result in wrong skinning"); } #endregion int startIndex = indices.Count; int indexCount = meshPart.m_indices.Count; uint minIndex = (uint)meshPart.m_indices[0]; foreach (var i in meshPart.m_indices) { indices.Add((uint)i); minIndex = Math.Min(minIndex, (uint)i); } uint baseVertex = minIndex; for (int i = startIndex; i < startIndex + indexCount; i++) { indices[i] -= minIndex; maxIndex = Math.Max(maxIndex, indices[i]); } #region Material var materialDesc = meshPart.m_MaterialDesc; var matId = MyMeshMaterials1.GetMaterialId(materialDesc, contentPath); var partKey = MyMeshMaterials1.Table[matId.Index].Technique; var materialName = MyMeshMaterials1.Table[matId.Index].Name; var list = submeshes.SetDefault(partKey, new List<MyDrawSubmesh>()); list.Add(new MyDrawSubmesh(indexCount, startIndex, (int)baseVertex, MyMeshMaterials1.GetProxyId(matId), bonesRemapping)); submeshesMeta.Add(new MySubmeshInfo { IndexCount = indexCount, StartIndex = startIndex, BaseVertex = (int)baseVertex, BonesMapping = bonesRemapping, Material = materialName.ToString(), Technique = partKey }); var list2 = submeshes2.SetDefault(partKey, new List<MySubmeshInfo>()); list2.Add(submeshesMeta[submeshesMeta.Count - 1]); #endregion } indicesNum = indices.Count; #region Fill gpu buffes unsafe { if (maxIndex <= ushort.MaxValue) { // create 16 bit indices var indices16 = new ushort[indices.Count]; for (int i = 0; i < indices.Count; i++) { indices16[i] = (ushort)indices[i]; } result.Indices = indices16; fixed (ushort* I = indices16) { indexBuffer = MyManagers.Buffers.CreateIndexBuffer(assetName + " index buffer", indices16.Length, new IntPtr(I), MyIndexBufferFormat.UShort, ResourceUsage.Immutable); } } else { var indicesArray = indices.ToArray(); fixed (uint* I = indicesArray) { indexBuffer = MyManagers.Buffers.CreateIndexBuffer(assetName + " index buffer", indices.Count, new IntPtr(I), MyIndexBufferFormat.UInt, ResourceUsage.Immutable); } } } unsafe { if (!hasBonesInfo) { var vertices = new MyVertexFormatPositionH4[verticesNum]; for (int i = 0; i < verticesNum; i++) { vertices[i] = new MyVertexFormatPositionH4(positions[i]); } meshVertexInput = meshVertexInput.Append(MyVertexInputComponentType.POSITION_PACKED); result.VertexPositions = vertices; fixed (MyVertexFormatPositionH4* V = vertices) { vertexBuffers.Add( MyManagers.Buffers.CreateVertexBuffer( assetName + " vertex buffer " + vertexBuffers.Count, verticesNum, sizeof(MyVertexFormatPositionH4), new IntPtr(V), ResourceUsage.Immutable)); } } else { var vertices = new MyVertexFormatPositionSkinning[verticesNum]; for (int i = 0; i < verticesNum; i++) { vertices[i] = new MyVertexFormatPositionSkinning( positions[i], new Byte4(boneIndices[i].X, boneIndices[i].Y, boneIndices[i].Z, boneIndices[i].W), boneWeights[i]); } meshVertexInput = meshVertexInput.Append(MyVertexInputComponentType.POSITION_PACKED) .Append(MyVertexInputComponentType.BLEND_WEIGHTS) .Append(MyVertexInputComponentType.BLEND_INDICES); fixed (MyVertexFormatPositionSkinning* V = vertices) { vertexBuffers.Add(MyManagers.Buffers.CreateVertexBuffer( assetName + " vertex buffer " + vertexBuffers.Count, verticesNum, sizeof(MyVertexFormatPositionSkinning), new IntPtr(V), ResourceUsage.Immutable)); } } // add second stream { var vertices = new MyVertexFormatTexcoordNormalTangent[verticesNum]; for (int i = 0; i < verticesNum; i++) { vertices[i] = new MyVertexFormatTexcoordNormalTangent(texcoords[i], normals[i], tangentBitanSgn[i]); } fixed (MyVertexFormatTexcoordNormalTangent* V = vertices) { vertexBuffers.Add(MyManagers.Buffers.CreateVertexBuffer( assetName + " vertex buffer " + vertexBuffers.Count, verticesNum, sizeof(MyVertexFormatTexcoordNormalTangent), new IntPtr(V), ResourceUsage.Immutable)); } result.VertexExtendedData = vertices; meshVertexInput = meshVertexInput .Append(MyVertexInputComponentType.NORMAL, 1) .Append(MyVertexInputComponentType.TANGENT_SIGN_OF_BITANGENT, 1) .Append(MyVertexInputComponentType.TEXCOORD0_H, 1); } } #endregion } #region Extract lods if (tagData.ContainsKey(MyImporterConstants.TAG_LODS)) { var tagLODs = tagData[MyImporterConstants.TAG_LODS]; if (((MyLODDescriptor[])tagLODs).Length > 0) { } LodDescriptors = (MyLODDescriptor[])((MyLODDescriptor[])tagLODs).Clone(); } #endregion if (missingMaterial) { Debug.WriteLine(String.Format("Mesh {0} has missing material", assetName)); } //indexBuffer.SetDebugName(assetName + " index buffer"); int c = 0; //vertexBuffers.ForEach(x => x.SetDebugName(assetName + " vertex buffer " + c++)); // result.BoundingBox = (BoundingBox)tagData[MyImporterConstants.TAG_BOUNDING_BOX]; result.BoundingSphere = (BoundingSphere)tagData[MyImporterConstants.TAG_BOUNDING_SPHERE]; result.VerticesNum = verticesNum; result.IndicesNum = indicesNum; result.VertexLayout = meshVertexInput; result.IB = indexBuffer; result.VB = vertexBuffers.ToArray(); result.IsAnimated = hasBonesInfo; result.Parts = submeshes.ToDictionary(x => x.Key, x => x.Value.ToArray()); result.PartsMetadata = submeshes2.ToDictionary(x => x.Key, x => x.Value.ToArray()); result.m_submeshes = submeshesMeta; IsAnimated |= result.IsAnimated; importer.Clear(); return result; }
static HtmlEntity() { _entityName = new Dictionary<int, string> { {160, "nbsp"}, {161, "iexcl"}, {162, "cent"}, {163, "pound"}, {164, "curren"}, {165, "yen"}, {166, "brvbar"}, {167, "sect"}, {168, "uml"}, {169, "copy"}, {170, "ordf"}, {171, "laquo"}, {172, "not"}, {173, "shy"}, {174, "reg"}, {175, "macr"}, {176, "deg"}, {177, "plusmn"}, {178, "sup2"}, {179, "sup3"}, {180, "acute"}, {181, "micro"}, {182, "para"}, {183, "middot"}, {184, "cedil"}, {185, "sup1"}, {186, "ordm"}, {187, "raquo"}, {188, "frac14"}, {189, "frac12"}, {190, "frac34"}, {191, "iquest"}, {192, "Agrave"}, {193, "Aacute"}, {194, "Acirc"}, {195, "Atilde"}, {196, "Auml"}, {197, "Aring"}, {198, "AElig"}, {199, "Ccedil"}, {200, "Egrave"}, {201, "Eacute"}, {202, "Ecirc"}, {203, "Euml"}, {204, "Igrave"}, {205, "Iacute"}, {206, "Icirc"}, {207, "Iuml"}, {208, "ETH"}, {209, "Ntilde"}, {210, "Ograve"}, {211, "Oacute"}, {212, "Ocirc"}, {213, "Otilde"}, {214, "Ouml"}, {215, "times"}, {216, "Oslash"}, {217, "Ugrave"}, {218, "Uacute"}, {219, "Ucirc"}, {220, "Uuml"}, {221, "Yacute"}, {222, "THORN"}, {223, "szlig"}, {224, "agrave"}, {225, "aacute"}, {226, "acirc"}, {227, "atilde"}, {228, "auml"}, {229, "aring"}, {230, "aelig"}, {231, "ccedil"}, {232, "egrave"}, {233, "eacute"}, {234, "ecirc"}, {235, "euml"}, {236, "igrave"}, {237, "iacute"}, {238, "icirc"}, {239, "iuml"}, {240, "eth"}, {241, "ntilde"}, {242, "ograve"}, {243, "oacute"}, {244, "ocirc"}, {245, "otilde"}, {246, "ouml"}, {247, "divide"}, {248, "oslash"}, {249, "ugrave"}, {250, "uacute"}, {251, "ucirc"}, {252, "uuml"}, {253, "yacute"}, {254, "thorn"}, {255, "yuml"}, {402, "fnof"}, {913, "Alpha"}, {914, "Beta"}, {915, "Gamma"}, {916, "Delta"}, {917, "Epsilon"}, {918, "Zeta"}, {919, "Eta"}, {920, "Theta"}, {921, "Iota"}, {922, "Kappa"}, {923, "Lambda"}, {924, "Mu"}, {925, "Nu"}, {926, "Xi"}, {927, "Omicron"}, {928, "Pi"}, {929, "Rho"}, {931, "Sigma"}, {932, "Tau"}, {933, "Upsilon"}, {934, "Phi"}, {935, "Chi"}, {936, "Psi"}, {937, "Omega"}, {945, "alpha"}, {946, "beta"}, {947, "gamma"}, {948, "delta"}, {949, "epsilon"}, {950, "zeta"}, {951, "eta"}, {952, "theta"}, {953, "iota"}, {954, "kappa"}, {955, "lambda"}, {956, "mu"}, {957, "nu"}, {958, "xi"}, {959, "omicron"}, {960, "pi"}, {961, "rho"}, {962, "sigmaf"}, {963, "sigma"}, {964, "tau"}, {965, "upsilon"}, {966, "phi"}, {967, "chi"}, {968, "psi"}, {969, "omega"}, {977, "thetasym"}, {978, "upsih"}, {982, "piv"}, {8226, "bull"}, {8230, "hellip"}, {8242, "prime"}, {8243, "Prime"}, {8254, "oline"}, {8260, "frasl"}, {8472, "weierp"}, {8465, "image"}, {8476, "real"}, {8482, "trade"}, {8501, "alefsym"}, {8592, "larr"}, {8593, "uarr"}, {8594, "rarr"}, {8595, "darr"}, {8596, "harr"}, {8629, "crarr"}, {8656, "lArr"}, {8657, "uArr"}, {8658, "rArr"}, {8659, "dArr"}, {8660, "hArr"}, {8704, "forall"}, {8706, "part"}, {8707, "exist"}, {8709, "empty"}, {8711, "nabla"}, {8712, "isin"}, {8713, "notin"}, {8715, "ni"}, {8719, "prod"}, {8721, "sum"}, {8722, "minus"}, {8727, "lowast"}, {8730, "radic"}, {8733, "prop"}, {8734, "infin"}, {8736, "ang"}, {8743, "and"}, {8744, "or"}, {8745, "cap"}, {8746, "cup"}, {8747, "int"}, {8756, "there4"}, {8764, "sim"}, {8773, "cong"}, {8776, "asymp"}, {8800, "ne"}, {8801, "equiv"}, {8804, "le"}, {8805, "ge"}, {8834, "sub"}, {8835, "sup"}, {8836, "nsub"}, {8838, "sube"}, {8839, "supe"}, {8853, "oplus"}, {8855, "otimes"}, {8869, "perp"}, {8901, "sdot"}, {8968, "lceil"}, {8969, "rceil"}, {8970, "lfloor"}, {8971, "rfloor"}, {9001, "lang"}, {9002, "rang"}, {9674, "loz"}, {9824, "spades"}, {9827, "clubs"}, {9829, "hearts"}, {9830, "diams"}, {34, "quot"}, {38, "amp"}, {60, "lt"}, {62, "gt"}, {338, "OElig"}, {339, "oelig"}, {352, "Scaron"}, {353, "scaron"}, {376, "Yuml"}, {710, "circ"}, {732, "tilde"}, {8194, "ensp"}, {8195, "emsp"}, {8201, "thinsp"}, {8204, "zwnj"}, {8205, "zwj"}, {8206, "lrm"}, {8207, "rlm"}, {8211, "ndash"}, {8212, "mdash"}, {8216, "lsquo"}, {8217, "rsquo"}, {8218, "sbquo"}, {8220, "ldquo"}, {8221, "rdquo"}, {8222, "bdquo"}, {8224, "dagger"}, {8225, "Dagger"}, {8240, "permil"}, {8249, "lsaquo"}, {8250, "rsaquo"}, {8364, "euro"} }; _entityValue = _entityName.ToDictionary(x => x.Value, x => x.Key); _maxEntitySize = 8 + 1; // we add the # char }
public DatObject(Dictionary<string, string> elements, Pak pak, DatFile file) { Pak = pak; DatFile = file; _dictionary = elements.ToDictionary(x => (string)x.Key, x => (string)x.Value); }
public DeleteItemResponse DeleteSingle(string tableName, Dictionary<string, object> dictionary) { var transformDictionary = dictionary.ToDictionary(x => x.Key, x => GetAttributeValueFromObject(x.Value)); return _client.DeleteItem(tableName, transformDictionary); }
public void WriteSingle(string tableName, Dictionary<string,object> dictionary) { var transformDictionary = dictionary.ToDictionary(x => x.Key, x => GetAttributeValueFromObject(x.Value)); _client.PutItem(tableName, transformDictionary); }
static TypesUtil() { PRIMITIVE_TYPES = new Dictionary<string, Type>() { {"void", typeof(void)}, {"bool", typeof(bool)}, {"object", typeof(object)}, {"string", typeof(string)}, {"char", typeof(char)}, {"double", typeof(double)}, {"int", typeof(int)}, {"long", typeof(long)}, {"decimal", typeof(decimal)} }; PRIMITIVE_TYPES_REV = PRIMITIVE_TYPES.ToDictionary(a => a.Value, a => a.Key); }
/// <summary> /// Vrátí pozice jednotlivých písmen ve slově /// </summary> /// <param name="text"></param> /// <returns></returns> private Dictionary<char, int[]> GetLettersPositions(string text) { Dictionary<char, List<int>> positions = new Dictionary<char, List<int>>(); for (int i = 0; i < text.Length; i++) { char currLetter = text[i]; if (positions.ContainsKey(currLetter)) { positions[currLetter].Add(i); } else { positions[currLetter] = new List<int>() { i }; } } return positions.ToDictionary(x => x.Key, x => x.Value.ToArray()); }
internal static IDictionary<string, object> TraverseForKeys( this object target, SupurlativeOptions options, string parentKey = null) { var kvp = new Dictionary<string, object>(); if (target == null) return kvp; var valueType = target as Type == null ? target.GetType() : target as Type; var properties = valueType .GetProperties(BindingFlags.Public | BindingFlags.Instance) .Where(x => x.CanWrite || valueType.CheckIfAnonymousType()); foreach (var property in properties) { var fullPropertyName = parentKey == null ? property.Name : string.Format("{0}{1}{2}", parentKey, options.PropertyNameSeperator, property.Name); object valueOrPropertyType = property.PropertyType; if (target as Type == null) { valueOrPropertyType = property.GetValue(target, null) ?? property.PropertyType; } var formatterAttribute = property.GetCustomAttributes() .Where(x => typeof(BaseFormatterAttribute).IsAssignableFrom(x.GetType())) .Cast<BaseFormatterAttribute>() .FirstOrDefault(); if (formatterAttribute == null) { // find any global formatters formatterAttribute = options .Formatters .Where(x => x.IsMatch(property.PropertyType, options)) .FirstOrDefault(); } if (formatterAttribute != null) { var targetValue = target == null || target as Type != null ? null : property.GetValue(target, null); try { formatterAttribute.Invoke( fullPropertyName, targetValue, property.PropertyType, kvp, options); } catch (Exception ex) { throw new FormatterException( string.Format("There is a problem invoking the formatter: {0}.", formatterAttribute.GetType().FullName), ex); } } else { var kvpValue = (valueOrPropertyType != null && valueOrPropertyType as Type == null ? valueOrPropertyType.ToString() : null); if (property.PropertyType.IsPrimitive || (!string.IsNullOrEmpty(property.PropertyType.Namespace) && property.PropertyType.Namespace.StartsWith("System"))) { kvp.Add(fullPropertyName, kvpValue); } else { var results = TraverseForKeys(valueOrPropertyType, options, fullPropertyName); if (results.Count() == 0) { kvp.Add(fullPropertyName, kvpValue); } else { foreach (var result in results) { kvp.Add(result.Key, result.Value); } } } } } return kvp.ToDictionary( x => options.LowercaseKeys ? x.Key.ToLower() : x.Key, x => x.Value ); }
public void SimulateAll() { var s2i = new Dictionary<State, int>(); var names = new Dictionary<string, Dictionary<string, State>>(); var allNCPatterns = NameTable .Values .SelectMany(x => x.p1.DescendantNodesAndSelf()) .ToList(); var allNamespaces = allNCPatterns .Where(x => x.Type == PatternType.NSNAME) .Distinct(); var allLocalNames = allNCPatterns .Where(x => x.Type == PatternType.LNNAME) .Distinct(); foreach (var ns in allNamespaces) { names.Add(ns.Namespace, new Dictionary<string, State>()); foreach (var ln in allLocalNames) { var all = NameTable .Where(x => Deriv(Deriv(x.Value.p1, ns), ln).Nullable) .Select(x => Define(x.Key, x.Value.p2)) .ToList(); if (all.Count == 0) continue; var state = Simulate(all.Aggregate(Choice)); names[ns.Namespace].Add(ln.Name, state); } } var nix = 1; var map = Pattern2State.Values.Distinct().ToDictionary(x => x, x => nix++); var names2 = names.ToDictionary(x => x.Key, x => x.Value.ToDictionary(y => y.Key, y => map[y.Value])); var defnull = NameTable.ToDictionary(x => x.Key, x => new HashSet<int>()); foreach (var entry in Pattern2State.Values.Distinct()) { entry.NullableDefines.ToList().ForEach(x => defnull[x].Add(map[entry])); } Func<Dictionary<string,State>, Dictionary<string,int>> helper = delegate(Dictionary<string,State> dict) { var nd = new Dictionary<string,int>(); foreach (var entry in dict) { defnull[entry.Key].ToList().ForEach(x => nd.Add(x.ToString(), map[entry.Value])); } return nd; }; var allstates = Pattern2State.Values .Distinct() .ToDictionary(x => map[x], x => new { Attributes = x.AttrStates.ToDictionary(y => y.Key, y => map[y.Value]), IsNullable = x.IsNullable, ChildElems = helper(x.ChildStates), }); var states = new object[allstates.Count + 1]; allstates.ToList().ForEach(x => states[x.Key] = x.Value); var serializer = new JavaScriptSerializer(); var text = serializer.Serialize(new { // DefNull = defnull, NameMap = names2, States = states }); TextWriter tw = new StreamWriter(Out); tw.Write(text); tw.Close(); }
private bool FulFillsPreconditionsCore(Dictionary<int, int> valueMapping, List<Effect> effectList, Stack<Effect> preconditionsStack) { var preconditionToFulFill = preconditionsStack.Pop(); if (preconditionToFulFill == null) return true; var matchingEffects = effectList.Where(x => x.EffectType == preconditionToFulFill.EffectType).ToList(); foreach (var matchingEffect in matchingEffects) { var valMapping = valueMapping.ToDictionary(x => x.Key, x => x.Value); if (!valMapping.ContainsKey(preconditionToFulFill.Parameter1.Value)) { valMapping.Add(preconditionToFulFill.Parameter1.Value, matchingEffect.Parameter1.Value); } else if (valMapping[preconditionToFulFill.Parameter1.Value] != matchingEffect.Parameter1.Value) { continue; } if (!valMapping.ContainsKey(preconditionToFulFill.Parameter2.Value)) { valMapping.Add(preconditionToFulFill.Parameter2.Value, matchingEffect.Parameter2.Value); } else if (valMapping[preconditionToFulFill.Parameter2.Value] != matchingEffect.Parameter2.Value) { continue; } if (!valueMapping.ContainsKey(preconditionToFulFill.Parameter3.Value)) { valueMapping.Add(preconditionToFulFill.Parameter3.Value, matchingEffect.Parameter2.Value); } else if (valMapping[preconditionToFulFill.Parameter3.Value] != matchingEffect.Parameter3.Value) { continue; } if (valueMapping[preconditionToFulFill.Parameter1.Value] == matchingEffect.Parameter1.Value && valueMapping[preconditionToFulFill.Parameter2.Value] == matchingEffect.Parameter2.Value && valueMapping[preconditionToFulFill.Parameter3.Value] == matchingEffect.Parameter3.Value) { FulFillsPreconditionsCore(valueMapping, effectList, preconditionsStack); } } return false; }
/// <summary> /// Write the pst data. /// </summary> /// <param name="pstFile">The pst file name to be stored.</param> /// <param name="data">The pst data to be write.</param> /// <param name="ttsPhoneSet">The tts Phone set.</param> /// <param name="ttsPosSet">The tts pst set.</param> public void WritePSTData(string pstFile, PSTData data, TtsPhoneSet ttsPhoneSet, TtsPosSet ttsPosSet) { foreach (Question question in data.DecisionForest.QuestionList) { question.Language = ttsPhoneSet.Language; question.ValueSetToCodeValueSet(ttsPosSet, ttsPhoneSet, data.CustomFeatures); } FileStream file = new FileStream(pstFile, FileMode.Create); try { using (DataWriter writer = new DataWriter(file)) { file = null; uint position = 0; // Write header section place holder PreselectionFileHeader header = new PreselectionFileHeader(); position += (uint)header.Write(writer); HtsFontSerializer serializer = new HtsFontSerializer(); using (StringPool stringPool = new StringPool()) { Dictionary<string, uint> questionIndexes = new Dictionary<string, uint>(); header.QuestionOffset = position; header.QuestionSize = serializer.Write( data.QuestionSet, writer, stringPool, questionIndexes, data.CustomFeatures); position += header.QuestionSize; // Write leaf referenced data to buffer List<CandidateSetData> dataNodes = data.CadidateSets; int val = data.CadidateSets.Sum(c => c.Candidates.Count); using (MemoryStream candidateSetBuffer = new MemoryStream()) { Dictionary<string, int> namedSetOffset = new Dictionary<string, int>(); int candidateSetSize = HtsFontSerializer.Write( dataNodes, new DataWriter(candidateSetBuffer), namedSetOffset); // Write decision forest Dictionary<string, uint[]> namedOffsets = namedSetOffset.ToDictionary(p => p.Key, p => new[] { (uint)p.Value }); header.DecisionTreeSectionOffset = position; header.DecisionTreeSectionSize = (uint)Write(data.DecisionForest, data.TreeIndexes, questionIndexes, data.QuestionSet, namedOffsets, new DecisionForestSerializer(), writer); position += header.DecisionTreeSectionSize; // Write string pool header.StringPoolOffset = position; header.StringPoolSize = HtsFontSerializer.Write(stringPool, writer); position += header.StringPoolSize; // Write leaf referenced data header.CandidateSetSectionOffset = position; header.CandidateSetSectionSize = writer.Write(candidateSetBuffer.ToArray()); position += header.CandidateSetSectionSize; } // Write header section place holder using (PositionRecover recover = new PositionRecover(writer, 0)) { header.Write(writer); } } } } finally { if (null != file) { file.Dispose(); } } }
public CreateSubstitutionClosure(Dictionary<Variable, Expr> map, bool fallBackOnName = false, Procedure proc = null) : base() { Contract.Requires(map != null); this.map = map; this.proc = proc; if (fallBackOnName && proc != null) { this.nameMap = map.ToDictionary(kv => UniqueName(kv.Key, proc), kv => kv.Value); } }
private static Dictionary<ErrorType, ErrorsSummary> _getTotalSummaryForCategory(Dictionary<ErrorType, IEnumerable<KeyValuePair<int, ErrorsSummary>>> summaries) { return summaries.ToDictionary(pair => pair.Key, pair => _getTotalSummaryForCategory(pair.Value)); }