public override void Invoke(Touch touch) { if (touch.State == TouchState.Begin) { Input.Value = GetText(); } if (touch.State == TouchState.End || touch.State == TouchState.Moving) { List <char> charShift = InputLabelStyle.Type == InputLabelType.Digits ? Digits : (InputLabelStyle.Type == InputLabelType.Characters ? Characters : All); string newValue = Input.Temp; int delta = touch.Session.PreviousTouch.AbsoluteY - touch.AbsoluteY; if (delta % charShift.Count != 0) { int charPosition = touch.Session.BeginTouch.X / 2; int charIndex = charShift.IndexOf(RawText[charPosition]); char newChar = charShift[((charIndex + delta) % charShift.Count + charShift.Count) % charShift.Count]; newValue = $"{RawText.Substring(0, charPosition)}{newChar}{RawText.Substring(charPosition + 1, (RawText.Length - charPosition - 1))}"; } if (touch.State == TouchState.End || InputLabelStyle.TriggerInRuntime) { SetValue(newValue, true, touch.Session.PlayerIndex); } else { SetTempValue(newValue, true); } } }
/// <summary> /// New position in stream. /// </summary> /// <param name="svc"></param> /// <param name="line">Received line.</param> /// <returns>true if it was processed by current handler, otherwise it means ignoring.</returns> public override bool Positioned(ISvc svc, RawText line) { if (svc.Sln.ExtItems == null) { svc.Sln.ExtItems = new Dictionary <string, string>(); } string _line; while ((_line = svc.ReadLine(this)) != null && _line.Trim() != "EndGlobalSection") { int pos = _line.IndexOf('='); if (pos < 0) // we will use non-strict processing { svc.Sln.ExtItems[_line.Trim()] = null; LSender.Send(this, $"Found extensible null record:{_line}", Message.Level.Info); continue; } string key = _line.Substring(0, pos).Trim(); string val = _line.Substring(pos + 1).Trim(); svc.Sln.ExtItems[key] = val; LSender.Send(this, $"Found extensible key-value: `{key}` = `{val}`", Message.Level.Info); } return(true); }
private bool IsNoNewlineAtEndOfFile(FileHeader fh) { HunkHeader lastHunk = fh.GetHunks()[fh.GetHunks().Count - 1]; RawText lhrt = new RawText(lastHunk.GetBuffer()); return(lhrt.GetString(lhrt.Size() - 1).Equals("\\ No newline at end of file")); }
// RZ: 5.6.2012 /// <summary> /// Loads the properties of the FreeMarker 'ftl' directive. /// </summary> private void loadTemplateProperties() { _StriptWhiteSpaces = false; try { if (RawText != string.Empty) { String startingTag = FTL_START_TAG; String endingTag = FTL_END_TAG; int startingPosition = 0; int endingPosition = 0; startingPosition = RawText.IndexOf(startingTag) + startingTag.Length; endingPosition = RawText.IndexOf(endingTag); String templateProperties = RawText.Substring(startingPosition, endingPosition - startingPosition); if (!String.IsNullOrEmpty(templateProperties)) { string[] pairs = templateProperties.Trim().Split(' '); foreach (String pair in pairs) { String[] value = pair.Split('='); value[0] = value[0].Trim(); if (value.Length == 2) { if (value[0].ToLower() == FTL_STRIP_WHITESPACE) { Boolean result = false; Boolean.TryParse(removeQuotes(value[1].Trim()), out result); _StriptWhiteSpaces = result; } } } } } } catch (Exception e) { } }
public void SetDataText(string newData) { RawText = RawText.Substring(0, DataStartIndex) // add preceding whitespace + newData.Replace("#", "\\#") // escape comments + RawText.Substring(DataEndIndex, RawText.Length - DataEndIndex); // add any following whitespace or comments }
public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITextSnapshot snapshot) { string fileName = textDocument.FilePath; GitFileStatusTracker tracker = new GitFileStatusTracker(Path.GetDirectoryName(fileName)); if (!tracker.IsGit) yield break; GitFileStatus status = tracker.GetFileStatus(fileName); if (status == GitFileStatus.New || status == GitFileStatus.Added) yield break; HistogramDiff diff = new HistogramDiff(); diff.SetFallbackAlgorithm(null); string currentText = snapshot.GetText(); byte[] preamble = textDocument.Encoding.GetPreamble(); byte[] content = textDocument.Encoding.GetBytes(currentText); if (preamble.Length > 0) { byte[] completeContent = new byte[preamble.Length + content.Length]; Buffer.BlockCopy(preamble, 0, completeContent, 0, preamble.Length); Buffer.BlockCopy(content, 0, completeContent, preamble.Length, content.Length); content = completeContent; } byte[] previousContent = null; //GetPreviousRevision(tracker, fileName); RawText b = new RawText(content); RawText a = new RawText(previousContent ?? new byte[0]); EditList edits = diff.Diff(RawTextComparator.DEFAULT, a, b); foreach (Edit edit in edits) yield return new HunkRangeInfo(snapshot, edit, a, b); }
private IEnumerable <InputValue> GetInputValues(string delimiterPattern) { var startIndex = 0; var delimiters = GetDelimiters(delimiterPattern); if (!delimiters.Any()) { yield return(new InputValue(RawText, Bias(startIndex))); yield break; } foreach (var delimiterMatch in delimiters) { yield return(new InputValue(RawText.Substring(startIndex, delimiterMatch.Index - startIndex), Bias(startIndex))); startIndex = delimiterMatch.Index + delimiterMatch.Length; } var last = delimiters.LastOrDefault(); if (last != null) { yield return(new InputValue(RawText.Substring(startIndex, RawText.Length - startIndex), Bias(startIndex))); } }
/// <param name="type">Allowed type of operations.</param> /// <param name="raw">Solution raw data.</param> /// <param name="projects">Dictionary of raw xml projects by Guid.</param> public Sln(SlnItems type, RawText raw, IDictionary <string, RawText> projects) { parser.RawXmlProjects = projects; using (var reader = new StreamReader(raw.data.GetStream(raw.encoding), raw.encoding)) { Result = parser.Parse(reader, type); } }
public IActionResult CreatePostVersion([FromBody] CreatePostVersionViewModel model) { var user = userRepository.GetApplicationUserByUsername(User.Identity.Name, true); if (user == null) { return(Unauthorized()); } var rawText = new RawText() { Text = "" }; var postVersion = new PostVersion() { Title = model.Title, RawText = rawText, PostId = model.PostId, PreviewText = "" }; try { postVersion = postRepository.CreatePostVersion(postVersion); return(Ok(Conversions.PostVersionViewModelFromPostVersion(postVersion))); } catch (Exception) { return(BadRequest()); } }
/// <summary> /// New position in stream. /// </summary> /// <param name="svc"></param> /// <param name="line">Received line.</param> /// <returns>true if it was processed by current handler, otherwise it means ignoring.</returns> public override bool Positioned(ISvc svc, RawText line) { if (svc.Sln.SolutionConfigList == null) { svc.Sln.SolutionConfigList = new List <IConfPlatform>(); } string _line; while ((_line = svc.ReadLine(this)) != null && _line.Trim() != "EndGlobalSection") { string left = _line.Before('=')?.Trim(); // Debug|Win32 = Debug|Win32 if (left == null || String.Compare(left, "DESCRIPTION", StringComparison.OrdinalIgnoreCase) == 0) { LSender.Send(this, $"Solution Configuration has been ignored for line '{_line}'", Message.Level.Debug); continue; } string[] cfg = left.Split('|'); if (cfg.Length < 2) { continue; } LSender.Send(this, $"Solution Configuration ->['{cfg[0]}' ; '{cfg[1]}']", Message.Level.Info); svc.Sln.SolutionConfigList.Add(new ConfigSln(cfg[0], cfg[1])); } return(true); }
public string GetDataText() { if (RawText.IsWhitespace()) return String.Empty; return RawText.Substring(DataStartIndex, DataEndIndex - DataStartIndex) .Replace("\\#", "#"); // unescape comments }
public LineAndCommit[] Blame(Commit commit, string path) { var leaf = commit.Tree[path] as Leaf; if (leaf == null) { throw new ArgumentException("The given path does not exist in this commit: " + path); } byte[] data = leaf.RawData; IntList lineMap = RawParseUtils.lineMap(data, 0, data.Length); var lines = new LineAndCommit[lineMap.size()]; var curText = new RawText(data); Commit prevAncestor = commit; Leaf prevLeaf = null; Commit prevCommit = null; int emptyLines = lineMap.size(); foreach (Commit ancestor in commit.Ancestors) { var cleaf = ancestor.Tree[path] as Leaf; if (prevCommit != null && (cleaf == null || cleaf.Hash != prevLeaf.Hash)) { byte[] prevData = prevLeaf.RawData; if (prevData == null) { break; } var prevText = new RawText(prevData); var differ = new MyersDiff(prevText, curText); foreach (Edit e in differ.getEdits()) { for (int n = e.BeginB; n < e.EndB; n++) { if (lines[n] == null) { lines[n] = CreateViewModel(GetLine(commit.Encoding, curText, n), prevCommit); emptyLines--; } } } if (cleaf == null || emptyLines <= 0) { break; } } prevCommit = ancestor; prevLeaf = cleaf; } for (int n = 0; n < lines.Length; n++) { if (lines[n] == null) { lines[n] = CreateViewModel(GetLine(commit.Encoding, curText, n), prevAncestor); } } return(lines); }
/// <summary> /// New position in stream. /// </summary> /// <param name="svc"></param> /// <param name="line">Received line.</param> /// <returns>true if it was processed by current handler, otherwise it means ignoring.</returns> public override bool Positioned(ISvc svc, RawText line) { string _line; while ((_line = svc.ReadLine(this)) != null && _line.Trim() != "EndGlobalSection") { int pos = _line.IndexOf('='); // Guids: src = dest if (pos < 0) { LSender.Send(this, $"Incorrect NestedProjects records: '{_line}'", Message.Level.Warn); return(false); } string src = _line.Substring(0, pos).Trim(); string dest = _line.Substring(pos + 1).Trim(); LSender.Send(this, $"NestedProjects '{src}' -> '{dest}'", Message.Level.Info); var parent = svc.Sln.SolutionFolderList.Where(f => f.header.pGuid == dest).First(); svc.Sln.SolutionFolderList.Where(f => f.header.pGuid == src) .ForEach(f => f.header.parent.Value = parent); svc.Sln.ProjectItemList.Where(p => p.pGuid == src) .ForEach(p => p.parent.Value = parent); } return(true); }
public Commit[] Blame(string path) { Leaf leaf = Tree [path] as Leaf; if (leaf == null) { throw new ArgumentException("The given path does not exist in this commit: " + path); } byte[] data = leaf.RawData; int lineCount = RawParseUtils.lineMap(data, 0, data.Length).size(); Commit[] lines = new Commit [lineCount]; var curText = new RawText(data); Commit prevAncestor = this; Leaf prevLeaf = null; Commit prevCommit = null; int emptyLines = lineCount; foreach (Commit ancestor in Ancestors) { Leaf cleaf = ancestor.Tree [path] as Leaf; if (prevCommit != null && (cleaf == null || cleaf.Hash != prevLeaf.Hash)) { byte[] prevData = prevLeaf.RawData; if (prevData == null) { break; } var prevText = new RawText(prevData); var differ = new MyersDiff(prevText, curText); foreach (Edit e in differ.getEdits()) { for (int n = e.BeginB; n < e.EndB; n++) { if (lines [n] == null) { lines [n] = prevCommit; emptyLines--; } } } if (cleaf == null || emptyLines <= 0) { break; } } prevCommit = ancestor; prevLeaf = cleaf; } for (int n = 0; n < lines.Length; n++) { if (lines [n] == null) { lines [n] = prevAncestor; } } return(lines); }
private bool IsNoNewlineAtEndOfFile(RawText lastRawTextOrDefault) { if (lastRawTextOrDefault != null) { return(lastRawTextOrDefault.GetString(lastRawTextOrDefault.Size() - 1).Equals("\\ No newline at end of file")); } return(false); }
/// <summary> /// Formats the results of a merge of <see cref="RawText"/> objects in a Git /// conformant way. This method also assumes that the <see cref="RawText"/> objects /// being merged are line oriented files which use LF as delimiter. This /// method will also use LF to separate chunks and conflict metadata, /// therefore it fits only to texts that are LF-separated lines. /// </summary> /// <param name="out">the outputstream where to write the textual presentation</param> /// <param name="res">the merge result which should be presented</param> /// <param name="seqName"> /// When a conflict is reported each conflicting range will get a /// name. This name is following the "<<<<<<< " or ">>>>>>> " /// conflict markers. The names for the sequences are given in /// this list /// </param> /// <param name="charsetName"> /// the name of the characterSet used when writing conflict /// metadata /// </param> public void formatMerge(BinaryWriter @out, MergeResult res, List <String> seqName, string charsetName) { String lastConflictingName = null; // is set to non-null whenever we are // in a conflict bool threeWayMerge = (res.getSequences().Count == 3); foreach (MergeChunk chunk in res) { RawText seq = (RawText)res.getSequences()[ chunk.getSequenceIndex()]; if (lastConflictingName != null && chunk.getConflictState() != MergeChunk.ConflictState.NEXT_CONFLICTING_RANGE) { // found the end of an conflict @out.Write((">>>>>>> " + lastConflictingName + "\n").getBytes(charsetName)); lastConflictingName = null; } if (chunk.getConflictState() == MergeChunk.ConflictState.FIRST_CONFLICTING_RANGE) { // found the start of an conflict @out.Write(("<<<<<<< " + seqName[chunk.getSequenceIndex()] + "\n").getBytes(charsetName)); lastConflictingName = seqName[chunk.getSequenceIndex()]; } else if (chunk.getConflictState() == MergeChunk.ConflictState.NEXT_CONFLICTING_RANGE) { // found another conflicting chunk /* * In case of a non-three-way merge I'll add the name of the * conflicting chunk behind the equal signs. I also append the * name of the last conflicting chunk after the ending * greater-than signs. If somebody knows a better notation to * present non-three-way merges - feel free to correct here. */ lastConflictingName = seqName[chunk.getSequenceIndex()]; @out.Write((threeWayMerge ? "=======\n" : "======= " + lastConflictingName + "\n").getBytes(charsetName)); } // the lines with conflict-metadata are written. Now write the chunk for (int i = chunk.getBegin(); i < chunk.getEnd(); i++) { if (i > 0) { @out.Write('\n'); } seq.writeLine(@out.BaseStream, i); } } // one possible leftover: if the merge result ended with a conflict we // have to close the last conflict here if (lastConflictingName != null) { @out.Write('\n'); @out.Write((">>>>>>> " + lastConflictingName + "\n").getBytes(charsetName)); } }
static IEnumerable <Hunk> GetDiffHunks(RawText curText, RawText ancestorText) { Dictionary <string, int> codeDictionary = new Dictionary <string, int> (); int codeCounter = 0; int[] ancestorDiffCodes = GetDiffCodes(ref codeCounter, codeDictionary, ancestorText); int[] currentDiffCodes = GetDiffCodes(ref codeCounter, codeDictionary, curText); return(Diff.GetDiff <int> (ancestorDiffCodes, currentDiffCodes)); }
public void testWriteLine2() { var a = new RawText(Constants.encodeASCII("foo-a\nfoo-b")); var o = new MemoryStream(); a.writeLine(o, 1); byte[] r = o.ToArray(); Assert.AreEqual("foo-b", RawParseUtils.decode(r)); }
public void testWriteLine3() { var a = new RawText(Constants.encodeASCII("a\n\nb\n")); var o = new MemoryStream(); a.writeLine(o, 1); byte[] r = o.ToArray(); Assert.AreEqual(string.Empty, RawParseUtils.decode(r)); }
public override bool ToCommand(IDaoProvider provider, SqlCommandBuilder builder, ISqlParameters parameters) { string sqlName = provider.EscapeParam(ParamName); builder.AppendCommandText(RawText.Replace(ParamName, sqlName)); builder.AddCommandParameter(sqlName, parameters.Resolve(ParamName)); return(true); }
/// <exception cref="System.IO.IOException"></exception> private void DecideMode() { isBinary = RawText.IsBinary(binbuf, binbufcnt); int cachedLen = binbufcnt; binbufcnt = binbuf.Length + 1; // full! Write(binbuf, 0, cachedLen); }
public string DiffFile(string fileName, string commitId1, string commitId2) { try { if (!this.HasGitRepository) { return(""); } var tmpFileName = Path.ChangeExtension(Path.GetTempFileName(), ".diff"); var fileNameRel = GetRelativeFileName(fileName); if (GitBash.Exists) { GitBash.RunCmd(string.Format("diff {2} {3} -- \"{0}\" > \"{1}\"", fileNameRel, tmpFileName, commitId1, commitId2), this.GitWorkingDirectory); } else { HistogramDiff hd = new HistogramDiff(); hd.SetFallbackAlgorithm(null); RawText a = string.IsNullOrWhiteSpace(commitId1) ? new RawText(new byte[0]) : new RawText(this.RepositoryGraph.GetFileContent(commitId1, fileNameRel) ?? new byte[0]); RawText b = string.IsNullOrWhiteSpace(commitId2) ? new RawText(new byte[0]) : new RawText(this.RepositoryGraph.GetFileContent(commitId2, fileNameRel) ?? new byte[0]); var list = hd.Diff(RawTextComparator.DEFAULT, a, b); using (Stream stream = new FileStream(tmpFileName, System.IO.FileMode.CreateNew)) { DiffFormatter df = new DiffFormatter(stream); df.Format(list, a, b); df.Flush(); } //using (Stream mstream = new MemoryStream(), // stream = new BufferedStream(mstream)) //{ // DiffFormatter df = new DiffFormatter(stream); // df.Format(list, a, b); // df.Flush(); // stream.Seek(0, SeekOrigin.Begin); // var ret = new StreamReader(stream).ReadToEnd(); // ret = ret.Replace("\r", "").Replace("\n", "\r\n"); // File.WriteAllText(tmpFileName, ret); //} } return(tmpFileName); } catch (Exception ex) { Log.WriteLine("Refresh: {0}\r\n{1}", this.initFolder, ex.ToString()); return(""); } }
public static RawText Parse(BinaryReader b, int stringLength) { var m = new RawText { Length = b.ReadByte(), Value = b.ReadBytes(stringLength) }; return(m); }
/* Function: DecodePropertyValue * Extracts the property value from the passed XML value, stripping off the surrounding quotes and any escaped quotes * within. */ private string DecodePropertyValue(int valueIndex, int valueLength) { string value = RawText.Substring(valueIndex + 1, valueLength - 2); value = value.Replace("\\\"", "\""); value = value.Replace("\\'", "'"); value = HTMLEntityChars.DecodeAll(value); return(value); }
/// <summary> /// New position in stream. /// </summary> /// <param name="svc"></param> /// <param name="line">Received line.</param> /// <returns>true if it was processed by current handler, otherwise it means ignoring.</returns> public override bool Positioned(ISvc svc, RawText line) { var pItem = new ProjectItem(line.trimmed, svc.Sln.SolutionDir); if (pItem.pGuid == null || !String.Equals(Guids.SLN_FOLDER, pItem.pType, StringComparison.OrdinalIgnoreCase)) { return(false); } LSender.Send(this, $"Found solution-folder: '{pItem.name}'", Message.Level.Info); var folderItems = new List <RawText>(); while ((line = svc.ReadLine(this)) != null && (line != "EndProject")) { if (!line.trimmed.StartsWith("ProjectSection(SolutionItems) = preProject", StringComparison.Ordinal)) { continue; } for (line = svc.ReadLine(this); line != null; line = svc.ReadLine(this)) { if (line.trimmed.StartsWith("EndProjectSection", StringComparison.Ordinal)) { break; } var item = line.trimmed.Before('='); if (item == null) { LSender.Send( this, $"Ignored incorrect item for '{pItem.name}':{pItem.pGuid} - '{line}'", Message.Level.Warn ); continue; } item = item.TrimEnd(); LSender.Send(this, $"Found item: '{item}'", Message.Level.Info); folderItems.Add(new RawText(item, svc.CurrentEncoding)); } } if (svc.Sln.SolutionFolderList == null) { svc.Sln.SolutionFolderList = new List <SolutionFolder>(); } svc.Sln.SolutionFolderList.Add(new SolutionFolder(pItem, folderItems)); return(true); }
private void loadTemplateText() { try { if (RawText != string.Empty) { TemplateText = RawText.Substring(RawText.IndexOf("-->") + 3); } } catch (Exception e) { throw new Exception("Didn't find the end of the xml block.", e); } }
public static List <SimpleEncounterData> Parse(string path) { var res = new List <SimpleEncounterData>(); using (BinaryReader b = new BinaryReader(File.Open(path, FileMode.Open))) { while (b.BaseStream.Position != b.BaseStream.Length) { var m = new SimpleEncounterData(); for (int i = 0; i < 4; ++i) { var codes = new short[8]; for (int j = 0; j < 8; ++j) { codes[j] = Convert.ToInt16(b.ReadByte()); } m.ChoiceCodes[i] = codes; } ; for (int i = 0; i < 4; ++i) { var args = new short[8]; for (int j = 0; j < 8; ++j) { args[j] = b.ReadInt16().SwapBytes(); } m.ChoiceArgs[i] = args; } for (int i = 0; i < 4; ++i) { m.ChoiceResultIndex[i] = Convert.ToInt16(b.ReadByte()); } m.CanBackout = b.ReadByte(); m.MaxTimes = b.ReadByte(); m.Unknown = b.ReadInt16().SwapBytes(); m.Prompt = b.ReadInt16().SwapBytes(); for (int i = 0; i < 4; ++i) { m.OptionTexts[i] = RawText.Parse(b, 79).ToString(); } res.Add(m); } } return(res); }
public void Delete(RawText rawText) { try { db.Entry(rawText).State = EntityState.Deleted; db.SaveChanges(); } catch (Exception ex) { Log.Error(ex.Message, ex); } }
/// <summary>Construct a new BlameResult for a generator.</summary> /// <remarks>Construct a new BlameResult for a generator.</remarks> /// <param name="gen">the generator the result will consume records from.</param> /// <returns> /// the new result object. null if the generator cannot find the path /// it starts from. /// </returns> /// <exception cref="System.IO.IOException">the repository cannot be read.</exception> public static NGit.Blame.BlameResult Create(BlameGenerator gen) { string path = gen.GetResultPath(); RawText contents = gen.GetResultContents(); if (contents == null) { gen.Release(); return(null); } return(new NGit.Blame.BlameResult(gen, path, contents)); }
public void Insert(RawText rawText) { try { db.RawTexts.Add(rawText); db.SaveChanges(); } catch (Exception ex) { Log.Error(ex.Message, ex); } }
// TODO: This method already exists in the Text class... private string GetLine(Encoding encoding, RawText text, int n) { if (n == text.LineStartIndices.size() - 1) { return(string.Empty); } int start = text.LineStartIndices.get(n + 1); int end = n + 2 >= text.LineStartIndices.size() ? text.Content.Count() : text.LineStartIndices.get(n + 2); return(encoding.GetString(text.Content, start, end - start).TrimEnd()); }
internal Text(RawText raw_text, Encoding encoding) { m_raw_text = raw_text; Encoding = encoding; }