Inheritance: TextReader
Example #1
5
        /// <summary>
        /// Processes the record.
        /// </summary>
        protected override void ProcessRecord()
        {
            this.WriteVerbose("Formatting log");
            using (var xmlReader = new StringReader(this.Log))
            {
                var xpath = new XPathDocument(xmlReader);
                using (var writer = new StringWriter())
                {
                    var transform = new XslCompiledTransform();
                    Func<string, string> selector = file => !Path.IsPathRooted(file) ? Path.Combine(Environment.CurrentDirectory, file) : file;
                    foreach (var fileToLoad in this.FormatFile.Select(selector))
                    {
                        this.WriteVerbose("Loading format file " + fileToLoad);
                        using (var stream = File.OpenRead(fileToLoad))
                        {
                            using (var reader = XmlReader.Create(stream))
                            {
                                transform.Load(reader);
                                transform.Transform(xpath, null, writer);
                            }
                        }
                    }

                    this.WriteObject(writer.GetStringBuilder().ToString(), false);
                }
            }
        }
        public string Visit(string text)
        {
            text = text.Trim();

            var lines = new List<string>();
            using (var stringReader = new StringReader(text))
            {
                string line;
                while ((line = stringReader.ReadLine()) != null)
                {
                    line = line.Trim();
                    lines.Add(line);
                }
            }

            lines.Sort();

            var stringBuilder = new StringBuilder();
            foreach (var line in lines)
            {
                stringBuilder.AppendLine(line);
            }

            return stringBuilder.ToString();
        }
Example #3
1
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            ++equationsCount;
            string xamlTextBox = XamlWriter.Save(t1);
            StringReader stringReader = new StringReader(xamlTextBox);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            TextBox newTextBox = (TextBox)XamlReader.Load(xmlReader);
            newTextBox.Name = "t" + equationsCount.ToString();
            newTextBox.Text = "";
            newTextBox.LostFocus += textBox_LostFocus;
            newTextBox.Margin = new Thickness(0, 29*(equationsCount-1) + 4, 6, 0);

            grid2.Children.Add(newTextBox);

            string xamlLabel = XamlWriter.Save(label2);
            stringReader = new StringReader(xamlLabel);
            xmlReader = XmlReader.Create(stringReader);
            Label newLabel = (Label)XamlReader.Load(xmlReader);
            newLabel.Name = "label" + (equationsCount*2).ToString();
            newLabel.Content = equationsCount.ToString() +":";
            newLabel.Margin = new Thickness(6, 29 * (equationsCount-1) + 4, 0, 0);

            grid2.Children.Add(newLabel);

            varForEq.Add(new List<string>());
        }
        public void Go()
        {
            var outputFile = Helpers.IO.GetClassOutputPath(this);
            var fixedHtml = FixBrokenServerControlMarkup(HTML);
            using (FileStream stream = new FileStream(
                outputFile,
                FileMode.Create,
                FileAccess.Write))
            {
                using (var document = new Document())
                {
                    PdfWriter writer = PdfWriter.GetInstance(
                        document, stream
                    );
                    document.Open();
                    using (var xmlSnippet = new StringReader(fixedHtml))
                    {
                        XMLWorkerHelper.GetInstance().ParseXHtml(
                            writer, document, xmlSnippet
                        );
                    }

                }
            }
        }
Example #5
0
		public static TriviaMessage Deserialize(string dataReceived)
		{
            /*
bool correctEnding = (dataReceived.EndsWith("</TriviaMessage>"));
if (!correctEnding)
{
	throw new InvalidOperationException("Deserialization will fail...");
}
             */
			XmlSerializer serializer = new XmlSerializer(typeof(TriviaMessage));
			StringReader reader = new StringReader(dataReceived);

			TriviaMessage message = null;

            try
            {
                message = (TriviaMessage)(serializer.Deserialize(reader));
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(string.Format("Failed to deserialize this data received '{0}'", dataReceived), ex);
            }

			reader.Close();
			
			return message;
		}
        public static object DeserializeAudioTracks(string tracksString)
        {
            XmlSerializer xmlDeSerializer = new XmlSerializer(typeof(List<BackgroundTrackItem>));
            StringReader textReader = new StringReader(tracksString);

            return xmlDeSerializer.Deserialize(textReader) as List<BackgroundTrackItem>;
        }
Example #7
0
        static LispReader()
        {
            _macros['"'] = new StringReader();
            _macros[';'] = new CommentReader();
            _macros['\''] = new WrappingReader(QUOTE);
            _macros['@'] = new WrappingReader(DEREF);//new DerefReader();
            _macros['^'] = new WrappingReader(META);
            _macros['`'] = new SyntaxQuoteReader();
            _macros['~'] = new UnquoteReader();
            _macros['('] = new ListReader();
            _macros[')'] = new UnmatchedDelimiterReader();
            _macros['['] = new VectorReader();
            _macros[']'] = new UnmatchedDelimiterReader();
            _macros['{'] = new MapReader();
            _macros['}'] = new UnmatchedDelimiterReader();
            ////	macros['|'] = new ArgVectorReader();
            _macros['\\'] = new CharacterReader();
            _macros['%'] = new ArgReader();
            _macros['#'] = new DispatchReader();

            _dispatchMacros['^'] = new MetaReader();
            _dispatchMacros['\''] = new VarReader();
            _dispatchMacros['"'] = new RegexReader();
            _dispatchMacros['('] = new FnReader();
            _dispatchMacros['{'] = new SetReader();
            _dispatchMacros['='] = new EvalReader();
            _dispatchMacros['!'] = new CommentReader();
            _dispatchMacros['<'] = new UnreadableReader();
            _dispatchMacros['_'] = new DiscardReader();
        }
Example #8
0
        public static Table Parse(IRestResponse response)
        {
            Table table = new Table();
            StringReader reader = new StringReader(response.Content);
            string readLine = reader.ReadLine();

            if (readLine != null)
            {
                string[] collection = readLine.Split(Separator);
                foreach (string column in collection)
                {
                    table.Columns.Add(column.TrimStart('"').TrimEnd('"'));
                }
            }

            string line = reader.ReadLine();

            while (!string.IsNullOrEmpty(line))
            {
                Row row = new Row(line);
                table.Rows.Add(row);
                line = reader.ReadLine();
            }

            return table;
        }
        public UnityEditor.EditorBuildSettingsScene[] GetPreviousScenesToRestore()
        {
            string text = null;
            if (Application.isEditor)
            {
                text = GetTextFromTempFile(previousScenes);
            }
                
            if(text != null)
            {
                var serializer = new System.Xml.Serialization.XmlSerializer(typeof(UnityEditor.EditorBuildSettingsScene[]));
                using(var textReader = new StringReader(text))
                {
                    try 
                    {
                        return (UnityEditor.EditorBuildSettingsScene[] )serializer.Deserialize(textReader);
                    }
                    catch (System.Xml.XmlException e)
                    {
						Debug.Log (e);
                        return null;
                    }
                }
            }
                
            return null;
        }
        public static BackgroundTrackItem DeserializeObjectAudioTrack(this string s)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(BackgroundTrackItem));
            StringReader textReader = new StringReader(s);

            return xmlSerializer.Deserialize(textReader) as BackgroundTrackItem;
        }
 public virtual void TestStemming()
 {
     TextReader reader = new StringReader("questões");
     TokenStream stream = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
     stream = TokenFilterFactory("PortugueseMinimalStem").Create(stream);
     AssertTokenStreamContents(stream, new string[] { "questão" });
 }
 public virtual void TestStemming()
 {
     TextReader reader = new StringReader("chevaux");
     TokenStream stream = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
     stream = TokenFilterFactory("FrenchMinimalStem").Create(stream);
     AssertTokenStreamContents(stream, new string[] { "cheval" });
 }
        public void TestConnectorSerialization()
        {
            var obj = new TwoInOneOutExpression();

            var tw = new StringWriter();
            using (var xw = XmlWriter.Create(tw))
            {
                xw.WriteStartElement("Node");
                obj.Serialize(xw);
                xw.WriteEndElement();
            }

            var sr = new StringReader(tw.ToString());
            using (var wr = XmlReader.Create(sr))
            {
                wr.ReadToFollowing("Node");
                var result = new TwoInOneOutExpression();
                result.Deserialize(wr);

                Assert.AreEqual(obj.Id, result.Id);
                Assert.AreEqual(obj.Connector1In.Id, result.Connector1In.Id);
                Assert.AreEqual(obj.Connector2In.Id, result.Connector2In.Id);
                Assert.AreEqual(obj.ConnectorOut.Id, result.ConnectorOut.Id);
            }
        }
        public PipelineContinuation StripResponseElement(ICommunicationContext context)
        {
            var passedApiUrl
                = (string)context.PipelineData["ApiUrl"];

            if (string.IsNullOrEmpty(passedApiUrl))
                return PipelineContinuation.Continue;

            var xmlDocument
                = (XmlDocument)context.PipelineData["ApiXmlResponse"];

            // read and remove response header to get result
            var responseElement = xmlDocument.SelectSingleNode("/response");
            var responseStatusAttribute = responseElement.Attributes["status"];

            var innerXml = responseElement.InnerXml;
            var stringReader = new StringReader(innerXml);

            // get the type
            Type generatedType = responseStatusAttribute.InnerText == "ok"
                                 	? _typeGenerator.GenerateType(passedApiUrl)
                                 	: typeof(Error);

            var serializer = new XmlSerializer(generatedType);
            object deserialized = serializer.Deserialize(stringReader);

            if (responseStatusAttribute.InnerText == "ok")
                context.OperationResult = new OperationResult.OK(deserialized);
            else
                context.OperationResult = new OperationResult.BadRequest { ResponseResource = deserialized };

            return PipelineContinuation.Continue;
        }
 public Document Parse(string commonMark)
 {
     using (var reader = new StringReader(commonMark))
     {
         return Parse(reader);
     }
 }
 public static string Filter(string stack)
 {
     if (stack == null)
     {
         return null;
     }
     StringWriter writer = new StringWriter();
     StringReader reader = new StringReader(stack);
     try
     {
         string str2;
         while ((str2 = reader.ReadLine()) != null)
         {
             if (!FilterLine(str2))
             {
                 writer.WriteLine(str2.Trim());
             }
         }
     }
     catch (Exception)
     {
         return stack;
     }
     return writer.ToString();
 }
		public void GenerateCode(FileProjectItem item, CustomToolContext context)
		{
			context.RunAsync(
				()=> {
					string fileName = item.FileName;
					var projectNode = item.Project;
					SpecFlowProject specFlowProject = CreateSpecFlowProjectFrom(projectNode);
					var specFlowGenerator = new SpecFlowGenerator(specFlowProject);
					
					string outputFile = context.GetOutputFileName(item, ".feature");
					
					var specFlowFeatureFile = specFlowProject.GetOrCreateFeatureFile(fileName);
					
					var fileContents = File.ReadAllText(fileName);
					string outputFileContents;
					using(var reader = new StringReader(fileContents)) {
						using (var writer = new StringWriter(new StringBuilder())) {
							specFlowGenerator.GenerateTestFile(specFlowFeatureFile, projectNode.LanguageProperties.CodeDomProvider, reader, writer);
							outputFileContents = writer.ToString();
						}
					}
					File.WriteAllText(outputFile, outputFileContents);
					
					WorkbenchSingleton.SafeThreadCall(
						() => context.EnsureOutputFileIsInProject(item, outputFile));
				});
		}
Example #18
0
 public void testFutureBaseRequest()
 {
     StringReader rdr = new StringReader("0030-delta-2011-03-13T05-38-00Z");
     DeltaRequestResultKind result = DeltaRequestHandler.handleDeltaRequest(deltaDir, new MasterNodeList<int>(),
         new MasterNodeList<int>(), new ToStringNodeValueExporter<int>(),rdr, new MemoryStream());
     Assert.AreEqual(DeltaRequestResultKind.Mismatch, result);
 }
 private async void UpdateContributors()
 {
     try
     {
         var vms = await Task.Run(async () =>
         {
             var hc = new HttpClient();
             var str = await hc.GetStringAsync(App.ContributorsUrl);
             using (var sr = new StringReader(str))
             {
                 var xml = XDocument.Load(sr);
                 return xml.Root
                           .Descendants("contributor")
                           .Where(
                               e =>
                               e.Attribute("visible") == null ||
                               e.Attribute("visible").Value.ToLower() != "false")
                           .Select(ContributorsViewModel.FromXml)
                           .ToArray();
             }
         });
         await DispatcherHelper.UIDispatcher.InvokeAsync(
             () =>
             {
                 this.Contributors.Clear();
                 this.Contributors.Add(new ContributorsViewModel("thanks to:", null));
                 vms.OrderBy(v => v.ScreenName ?? "~" + v.Name)
                    .ForEach(this.Contributors.Add);
             });
     }
     catch (Exception ex)
     {
         System.Diagnostics.Debug.WriteLine(ex);
     }
 }
Example #20
0
 /// <summary>
 /// 读取指定节点的值
 /// </summary>
 /// <param name="XmlPathNode">节点的XPATH</param>
 /// <returns>返回一个DataView</returns>
 public DataSet GetData(string XmlPathNode)
 {
     DataSet ds = new DataSet();
     StringReader read = new StringReader(objXmlDoc.SelectSingleNode(XmlPathNode).OuterXml);
     ds.ReadXml(read);
     return ds;
 }
Example #21
0
        public static IList<string> ParseInstalledPluginsFile(string filePath)
        {
            //read and parse the file
            if (!File.Exists(filePath))
                return new List<string>();

            var text = File.ReadAllText(filePath);
            if (String.IsNullOrEmpty(text))
                return new List<string>();
            
            //Old way of file reading. This leads to unexpected behavior when a user's FTP program transfers these files as ASCII (\r\n becomes \n).
            //var lines = text.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
            
            var lines = new List<string>();
            using (var reader = new StringReader(text))
            {
                string str;
                while ((str = reader.ReadLine()) != null)
                {
                    if (String.IsNullOrWhiteSpace(str))
                        continue;
                    lines.Add(str.Trim());
                }
            }
            return lines;
        }
Example #22
0
		public void Activate(string[] args)
		{
			bool verbose = false;
			if (args.Length > 0)
			{
				foreach (string arg in args)
				{
					if (arg.ToLower() ==  "/verbose")
						verbose = true;
				}
			}
			try
			{
				runtime = new Runtime();
				Environment globalEnvironment = new Environment();
				foreach (string line in LSharpCode)
				{
					if (verbose)
						Console.Write(line + " --> ");
					System.IO.StringReader reader = new System.IO.StringReader(line);
					object output = Runtime.EvalString(line, globalEnvironment);
					Console.WriteLine(Printer.WriteToString(output));
				}
			}
			catch (Exception e)
			{
				Console.WriteLine(e.ToString());
			}
			System.Console.WriteLine("Press any key to Continue...");
			System.Console.ReadKey(true);
		}
		public static IEnumerable<string> ReadLines(this string content)
		{
			string line;
			using (var sr = new StringReader(content))
				while ((line = sr.ReadLine()) != null)
					yield return line;
		}
        public List<SequenceContract> ParseFastaFile(string fastaContent)
        {
            StringReader sr = new StringReader(fastaContent);
            List<SequenceContract> sequences = new List<SequenceContract>();
            SequenceList bioSeqList = null;

            using (ReaderBase reader = new BioFastaReader())
            {
                bioSeqList = reader.Read(sr);
            }

            foreach (Sequence seq in bioSeqList)

                sequences.Add
                    (new SequenceContract()
                            {
                                Name = seq.Annotations("SequenceName").AnnotationValue as string,
                                AlphabetName = seq.Alphabet.Name,
                                Characters = seq.Letters()
                            }
                    );


            return sequences;
        }
        public static object Deserialize(string xmlContent, string serializerType)
        {
            object returnValue = null;
            SerializerTypes serializerTypeValue;
            Type instanceType;
            GetSerializerDetails(serializerType, out serializerTypeValue, out instanceType);

            if (serializerTypeValue == SerializerTypes.XmlSerializer)
            {
                StringReader sww = new StringReader(xmlContent);
                XmlReader reader = XmlReader.Create(sww);
                System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(instanceType);
                returnValue = serializer.Deserialize(reader);
            }
            else if (serializerTypeValue == SerializerTypes.XmlObjectSerializer)
            {
                XmlObjectSerializer serializer = new XmlObjectSerializer();
                returnValue = serializer.Deserialize(xmlContent, true);
            }
            else
            {
                if (instanceType == typeof(string))
                {
                    returnValue = xmlContent;
                }
                else
                {
                    var method = instanceType.GetMethod("Parse", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
                    returnValue = method.Invoke(null, new object[] { xmlContent });
                }
            }
            return returnValue;
        }
 public virtual void TestPositionIncrements()
 {
     Reader reader = new StringReader("foo foobar super-duper-trooper");
     TokenStream stream = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
     stream = TokenFilterFactory("Length", LengthFilterFactory.MIN_KEY, "4", LengthFilterFactory.MAX_KEY, "10").Create(stream);
     AssertTokenStreamContents(stream, new string[] { "foobar" }, new int[] { 2 });
 }
 protected void btnPDF_Click(object sender, ImageClickEventArgs e)
 {
     Response.ContentType = "application/pdf";
     Response.AddHeader("content-disposition", "attachment;filename=UserDetails.pdf");
     Response.Cache.SetCacheability(HttpCacheability.NoCache);
     var sw = new StringWriter();
     var hw = new HtmlTextWriter(sw);
     gvdetails.AllowPaging = false;
     gvdetails.DataBind();
     gvdetails.RenderControl(hw);
     gvdetails.HeaderRow.Style.Add("width", "15%");
     gvdetails.HeaderRow.Style.Add("font-size", "10px");
     gvdetails.Style.Add("text-decoration", "none");
     gvdetails.Style.Add("font-family", "Arial, Helvetica, sans-serif;");
     gvdetails.Style.Add("font-size", "8px");
     var sr = new StringReader(sw.ToString());
     var pdfDoc = new Document(PageSize.A2, 7f, 7f, 7f, 0f);
     var htmlparser = new HTMLWorker(pdfDoc);
     PdfWriter.GetInstance(pdfDoc, Response.OutputStream);
     pdfDoc.Open();
     htmlparser.Parse(sr);
     pdfDoc.Close();
     Response.Write(pdfDoc);
     Response.End();
 }
		private List<double> significance_level;		        //Уровнь значимости

		//Загружает таблицу критических значений
		private CriticalPirsonCriterion()
		{

			try
			{
				using (var sr = new StringReader(Resources.PirsonCritical))
				{
					int k = 1;          //Степень свободы
					string line;        //Текущая строка

					table = new List<Dictionary<double, double>>();

					//Парсим первую строку с уровнями значимости
					line = sr.ReadLine();
					significance_level = get_significance_levle(line);

					//Читаем оставшиеся строки и заполняем таблицу
					while ((line = sr.ReadLine()) != null)
						table.Add(get_line_values(line, significance_level));
				}
			}
			catch(FormatException exp)
			{
				throw new Exception("ОШИБКА ФАЙЛА КРИТИЧЕСКИХ ТОЧЕК: значение в файле не является числом");
			}
			catch(IOException exp)
			{
				throw new Exception("ОШИБКА ФАЙЛА КРИТИЧЕСКИХ ТОЧЕК: не удается открыть файл");
			}
			catch(Exception exp)
			{
				throw exp;
			}
		}
        private static void CheckSplits(string testString, string expectedSplits)
        {
            StringReader r = new StringReader(testString);
            var filter = SnowballAndWordSplittingAnalyzer.GetStandardFilterSet(r);

            int expectToFindThisMany = expectedSplits.Split().Length;
            var expectedSplitWords = new HashSet<string>();
            foreach (var term in expectedSplits.Split())
                expectedSplitWords.Add(term.ToLower());
            var notExpected = new HashSet<string>();

            Token token = filter.Next();
            HashSet<string> foundSplits = new HashSet<string>() ;
            while (token!=null && !String.IsNullOrEmpty(token.ToString()))
            {
                Debug.WriteLine(token.Term());
                int before = expectedSplitWords.Count;
                expectedSplitWords.Remove(token.Term());
                int after = expectedSplitWords.Count;
                if (before == after)
                    notExpected.Add(token.Term());
                foundSplits.Add(token.Term());
                token = filter.Next();
            }
            Assert.AreEqual(0, expectedSplitWords.Count);
            Assert.AreEqual(foundSplits.Count, expectToFindThisMany, string.Join(", ", notExpected));
        }
        public void Run_should_populate_StartTime_and_EndTime_and_TotalRunTime()
        {
            // Arrange
            var beforeStart = DateTime.UtcNow;
            var config = new Config();
            var testCaseReader = new TestCaseReaderMock();
            var stringReader = new StringReader("");

            var response = new HttpResponse();
            response.ResponseTime = TimeSpan.FromSeconds(5);

            HttpClientMock httpClient = new HttpClientMock(response);
            IResultWriter resultWriter = new ResultWriterStub();
            var runner = new TestSessionRunner(config, httpClient, resultWriter);

            var caseCollection = CreateCaseCollection(new[]
            {
                new Case() { Url = "foo1" },
            });

            // Act
            TestCaseSession session = runner.Run(caseCollection);

            // Assert
            Assert.That(session.StartTime, Is.GreaterThanOrEqualTo(beforeStart));
            Assert.That(session.EndTime, Is.GreaterThanOrEqualTo(session.StartTime));
            Assert.That(session.TotalRunTime, Is.EqualTo(session.EndTime - session.StartTime));
        }
Example #31
0
 public new static ListMonadicFunctionsBoolType111 Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((ListMonadicFunctionsBoolType111)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public static retourBevestigingBevestiging Deserialize(string xml)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(xml);
         return((retourBevestigingBevestiging)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public static TemplateAdminTypeDigitalSignatureSignaturePropertiesX_CertificateAuthority Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((TemplateAdminTypeDigitalSignatureSignaturePropertiesX_CertificateAuthority)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
Example #34
0
 public static artikelEigenschapArtikelEigenschapGegevens Deserialize(string xml)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(xml);
         return((artikelEigenschapArtikelEigenschapGegevens)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
Example #35
0
        public static IEnumerable <string> SplitToLines(this string input)
        {
            if (input == null)
            {
                yield break;
            }

            using (System.IO.StringReader reader = new System.IO.StringReader(input))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    yield return(line);
                }
            }
        }
Example #36
0
 public static NumTrigNumType111TrigRadians Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((NumTrigNumType111TrigRadians)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
Example #37
0
 public new static ContactType Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((ContactType)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public new static TemplateAdminTypeDigitalSignature Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((TemplateAdminTypeDigitalSignature)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public new static negativeInteger_Stype Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((negativeInteger_Stype)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public new static ListFilterListType000 Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((ListFilterListType000)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
Example #41
0
 public static TRetEnviNFeInfRec Deserialize(string xml)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(xml);
         return((TRetEnviNFeInfRec)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public static BalanzaCtas Deserialize(string xml)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(xml);
         return((BalanzaCtas)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public new static SimpleSdcRetrieveFormPackageTypeXMLPackageReportDesignTemplate Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((SimpleSdcRetrieveFormPackageTypeXMLPackageReportDesignTemplate)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
Example #44
0
    private void LoadPlayerValues()
    {
        XmlSerializer serializer = new XmlSerializer(typeof(PlayerValues));
        string        text       = PlayerPrefs.GetString("player values");

        if (text.Length == 0)
        {
            playerValues = new PlayerValues();
        }
        else
        {
            using (var reader = new System.IO.StringReader(text)) {
                playerValues = serializer.Deserialize(reader) as PlayerValues;
            }
        }
    }
 public new static SDCPackageList Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((SDCPackageList)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
Example #46
0
 public new static IsBetweenTypeMin_Expression Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((IsBetweenTypeMin_Expression)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public new static NominaReceptorSubContratacion Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((NominaReceptorSubContratacion)(Serializer.Deserialize(XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
 public new static PredicateCompareType Deserialize(string input)
 {
     System.IO.StringReader stringReader = null;
     try
     {
         stringReader = new System.IO.StringReader(input);
         return((PredicateCompareType)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
     }
     finally
     {
         if ((stringReader != null))
         {
             stringReader.Dispose();
         }
     }
 }
Example #49
0
        /// <summary>
        /// Must override this, this is the bit that matches up the designer properties to the dictionary values
        /// </summary>
        /// <param name="context"></param>
        /// <param name="collection"></param>
        /// <returns></returns>
        public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
        {
            //load the file
            if (!_loaded)
            {
                _loaded = true;
                LoadValuesFromFile();
            }

            //collection that will be returned.
            SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();

            //itterate thought the properties we get from the designer, checking to see if the setting is in the dictionary
            foreach (SettingsProperty setting in collection)
            {
                SettingsPropertyValue value = new SettingsPropertyValue(setting);
                value.IsDirty = false;

                //need the type of the value for the strong typing
                var t = Type.GetType(setting.PropertyType.FullName);

                if (setting.PropertyType == typeof(System.Collections.Specialized.StringCollection))
                {
                    var xml          = SettingsDictionary[setting.Name].value;
                    var stringReader = new System.IO.StringReader(xml);
                    var xmlreader    = System.Xml.XmlReader.Create(stringReader);
                    var ser          = new System.Xml.Serialization.XmlSerializer(typeof(System.Collections.Specialized.StringCollection));
                    var obj          = ser.Deserialize(xmlreader);
                    var col          = (System.Collections.Specialized.StringCollection)obj;
                    value.PropertyValue = col;
                }
                else if (SettingsDictionary.ContainsKey(setting.Name))
                {
                    value.SerializedValue = SettingsDictionary[setting.Name].value;
                    value.PropertyValue   = Convert.ChangeType(SettingsDictionary[setting.Name].value, t);
                }
                else     //use defaults in the case where there are no settings yet
                {
                    value.SerializedValue = setting.DefaultValue;
                    value.PropertyValue   = Convert.ChangeType(setting.DefaultValue, t);
                }

                values.Add(value);
            }
            return(values);
        }
Example #50
0
        private void GetPictures(CT_GraphicalObjectData god, List <NPOI.OpenXmlFormats.Dml.Picture.CT_Picture> pictures)
        {
            XmlSerializer xmlse = new XmlSerializer(typeof(NPOI.OpenXmlFormats.Dml.Picture.CT_Picture));

            foreach (string el in god.Any)
            {
                if (el.IndexOf("pic:pic") < 0)
                {
                    continue;
                }
                System.IO.StringReader stringReader = new System.IO.StringReader(el);

                NPOI.OpenXmlFormats.Dml.Picture.CT_Picture pict =
                    xmlse.Deserialize(System.Xml.XmlReader.Create(stringReader)) as NPOI.OpenXmlFormats.Dml.Picture.CT_Picture;
                pictures.Add(pict);
            }
        }
Example #51
0
        /// <summary>
        /// Attempts to create an SVG document from the specified string data.
        /// </summary>
        /// <param name="svg">The SVG data.</param>
        public static T FromSvg <T>(string svg) where T : SvgDocument, new()
        {
            if (string.IsNullOrEmpty(svg))
            {
                throw new ArgumentNullException("svg");
            }

            using (var strReader = new System.IO.StringReader(svg))
            {
                var reader = new SvgTextReader(strReader, null)
                {
                    XmlResolver        = new SvgDtdResolver(),
                    WhitespaceHandling = WhitespaceHandling.Significant
                };
                return(Open <T>(reader));
            }
        }
Example #52
0
        // Populates the CSV reader dictionary.
        /// <param name="fileName">Gets the path name.</param>
        public Dictionary <string, string> ReadFile(string fileName)
        {
            Dictionary <string, string> output = new Dictionary <string, string>();

            string csvText = System.IO.File.ReadAllText(fileName);

            using (System.IO.StringReader reader = new System.IO.StringReader(csvText))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    string[] vals = line.Split(',');
                    output.Add(vals[0], line.Substring(vals[0].Length + 1));
                }
            }
            return(output);
        }
Example #53
0
        public string TransformXML(string xml, string xsl)
        {
            System.IO.StringReader stringReader = null;
            System.Xml.Xsl.XslCompiledTransform xslTransform  = null;
            System.Xml.XmlTextReader            xmlTextReader = null;
            System.IO.MemoryStream   xmlTextWriterStream      = null;
            System.Xml.XmlTextWriter xmlTextWriter            = null;
            System.Xml.XmlDocument   xmlDocument  = null;
            System.IO.StreamReader   streamReader = null;
            //System.Security.Policy.Evidence evidence = null;
            try
            {
                stringReader        = new System.IO.StringReader(xsl);
                xslTransform        = new System.Xml.Xsl.XslCompiledTransform();
                xmlTextReader       = new System.Xml.XmlTextReader(stringReader);
                xmlTextWriterStream = new System.IO.MemoryStream();
                xmlTextWriter       = new System.Xml.XmlTextWriter(xmlTextWriterStream, System.Text.Encoding.Default);
                xmlDocument         = new System.Xml.XmlDocument();

                //evidence =  new System.Security.Policy.Evidence();
                //evidence.AddAssembly(this);
                xmlDocument.LoadXml(xml);
                xslTransform.Load(xmlTextReader);
                xslTransform.Transform(xmlDocument, null, xmlTextWriter, null);
                xmlTextWriter.Flush();

                xmlTextWriterStream.Position = 0;
                streamReader = new System.IO.StreamReader(xmlTextWriterStream);
                return(streamReader.ReadToEnd());
            }
            catch (Exception exc)
            {
                LogEvent(exc.Source, "TransformXML()", exc.ToString(), 4);
                return("");
            }
            finally
            {
                streamReader.Close();
                xmlTextWriter.Close();
                xmlTextWriterStream.Close();
                xmlTextReader.Close();
                stringReader.Close();
                GC.Collect();
            }
        }
Example #54
0
        // Display any warnings or errors.


        public static bool CanDeserialize(string xml)
        {
            System.IO.StringReader stringReader = null;
            try
            {
                var settings = new XmlReaderSettings();
                settings.ValidationType = ValidationType.Schema;
                stringReader            = new System.IO.StringReader(xml);
                return(Serializer.CanDeserialize(System.Xml.XmlReader.Create(stringReader, settings)));
            }
            finally
            {
                if ((stringReader != null))
                {
                    stringReader.Dispose();
                }
            }
        }
Example #55
0
        public void SetupBuilderLoadConfigurationFromXmlPatchTest()
        {
            // Arrange
            var xmlFile      = new System.IO.StringReader("<nlog autoshutdown='true'></nlog>");
            var appEnv       = new Mocks.AppEnvironmentMock(f => true, f => System.Xml.XmlReader.Create(xmlFile));
            var configLoader = new LoggingConfigurationFileLoader(appEnv);
            var logFactory   = new LogFactory(configLoader);

            // Act
            logFactory.Setup().
            LoadConfigurationFromXml("<nlog autoshutdown='false'></nlog>").
            LoadConfigurationFromFile().      // No effect, since config already loaded
            LoadConfiguration(b => { b.Configuration.Variables["Hello"] = "World"; });

            // Assert
            Assert.False(logFactory.AutoShutdown);
            Assert.Single(logFactory.Configuration.Variables);
        }
Example #56
0
 /// <summary>
 /// Deserializes workflow markup into an Root object
 /// </summary>
 // <param name="xml">string workflow markup to deserialize</param>
 // <param name="obj">Output Root object</param>
 // <param name="exception">output Exception value if deserialize failed</param>
 // <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
 public static bool Deserialize(string xml, out Root obj, out System.Exception exception)
 {
     exception = null;
     obj       = null;
     try
     {
         System.IO.StringReader   stringReader  = new System.IO.StringReader(xml);
         System.Xml.XmlTextReader xmlTextReader = new System.Xml.XmlTextReader(stringReader);
         System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(Root));
         obj = ((Root)(xmlSerializer.Deserialize(xmlTextReader)));
         return(true);
     }
     catch (System.Exception e)
     {
         exception = e;
         return(false);
     }
 }
        internal ExpressionElement Parse(string expression, IServiceProvider services)
        {
            lock (_mySyncRoot)
            {
                System.IO.StringReader sr     = new System.IO.StringReader(expression);
                ExpressionParser       parser = this.Parser;
                parser.Reset(sr);
                parser.Tokenizer.Reset(sr);
                FleeExpressionAnalyzer analyzer = (FleeExpressionAnalyzer)parser.Analyzer;

                analyzer.SetServices(services);

                Node rootNode = DoParse();
                analyzer.Reset();
                ExpressionElement topElement = (ExpressionElement)rootNode.Values[0];
                return(topElement);
            }
        }
        private static NoteDataXML_Table LoadStringAsTable(string data)
        {
            // Loading existing table
            System.IO.StringReader LinkTableReader = new System.IO.StringReader(data);
            System.Xml.Serialization.XmlSerializer LinkTableXML = new System.Xml.Serialization.XmlSerializer(typeof(NoteDataXML_Table));

            NoteDataXML_Table table = new NoteDataXML_Table();

            table = (NoteDataXML_Table)LinkTableXML.Deserialize(LinkTableReader);
            //						if (table != null)
            //						{
            //							MyLinkTable.SetTable (table.dataSource);
            //						}
            //NewMessage.Show("Loading a link table with GUID = " + table.GuidForNote);
            LinkTableXML = null;
            LinkTableReader.Close();
            LinkTableReader.Dispose();
            return(table);
        }
Example #59
0
    public void FinallyLoad(List <GameEditorData> Risto, int i)
    {
        //	porigon.blocks = Risto[i].blocks;
        ManagerEditor.GameName = Risto[i].Name;
        porigon.EditorUpdateMesh();
        gameObject.SetActive(false);

        GEDContainer ola        = new GEDContainer();
        var          configFile = Resources.Load("savedPatterns") as TextAsset;
        var          serializer = new XmlSerializer(typeof(GEDContainer));

        using (var reader = new System.IO.StringReader(configFile.text))
        {
            ola = serializer.Deserialize(reader) as GEDContainer;
        }
        print("Oi, eu sou o " + ola.savedPatterns[i].Name);
        porigon.blocks = ConvertToMulti(ola.savedPatterns[i].blocks);
        porigon.EditorUpdateMesh();
    }
Example #60
0
        public void LoadVals(string strXml)
        {
            XmlSerializer         s;
            StringReader          sr;
            CODocumentReleaseType o;

            s  = new XmlSerializer(typeof(CODocumentReleaseType));
            sr = new System.IO.StringReader(strXml);

            o = new CODocumentReleaseType();
            o = (CODocumentReleaseType)s.Deserialize(sr);

            base.LoadFromObj(o);

            o = null;
            sr.Close();
            sr = null;
            s  = null;
        }