private dynamic EnsureIterable(dynamic subject) { if (subject is IIterable) { Subject = subject; return subject; } if (subject is string) { subject = new string[] {subject}; } if (subject is IEnumerable) { var iterable = new Iterable(); foreach (var item in subject) { iterable.Add(item); } subject = iterable; } Subject = subject; return Subject; }
public NGitPushResultAdapter (Iterable<PushResult> pushResults) { try { foreach (var pushResult in pushResults) { Msg += newLine + "PushResult......"; var remoteUpdates = pushResult.GetRemoteUpdates (); foreach (var remoteUpdate in remoteUpdates) { var oldObjectId = remoteUpdate.GetTrackingRefUpdate ().GetOldObjectId ().Name; var newObjectId = remoteUpdate.GetTrackingRefUpdate ().GetNewObjectId ().Name; Msg += newLine + "Old object id: " + oldObjectId; Msg += newLine + "New object id: " + newObjectId; var refResult = remoteUpdate.GetTrackingRefUpdate ().GetResult (); Msg += newLine + "refResult: " + refResult; var status = remoteUpdate.GetStatus (); Msg += newLine + "STATUS: " + status; UpdateSuccessStatus (status); if (remoteUpdate.GetMessage () != null) { Msg += newLine + remoteUpdate.GetMessage (); } } } } catch (System.Exception ex) { this.Exception = new GitCommandException ("Error NGitPushResultAdapter", ex); } }
public static void m(Iterable<Customers> customers) { var query = from c in customers from o in c.Orders orderby o.Total descending select new { c.Name, o.Total }; }
public Iterable<String> getAllReferencingTypes(Iterable<String> typeNames) { var result = new HashSet<String>(); foreach (var t in typeNames) { visitReferencingTypes(t, result); } return result; }
public static void m(Iterable<Customers> customers) { var query = from c in customers join o in orders on c.CustomerID equals o.CustomerID join d in details on o.OrderID equals d.OrderID join p in products on d.ProductID equals p.ProductID select new { c.Name, o.OrderDate, p.ProductName }; }
public ContentAssistContext(Library typeSystem, Library annotatedTypeSystem) { this.typeSystem = typeSystem; this.annotatedTypeSystem = annotatedTypeSystem; this.packageNames = Query.empty(); this.packageInfos = new ArrayList<PackageInfo>(); this.typeInfos = new ArrayList<TypeInfo>(); this.methodInfos = new ArrayList<MethodInfo>(); this.localInfos = new ArrayList<MemberInfo>(); }
public virtual bool matchesSafely(Iterable collection) { Iterator iterator = collection.iterator(); while (iterator.hasNext()) { if (this.elementMatcher.matches(iterator.next())) return true; } return false; }
private string join(Iterable<String> items, int limit) { StringBuilder sb = new StringBuilder(); int count = 0; foreach (string item in items) { if (count > 0) sb.append(", "); sb.append(item); if (limit > 0 && count == limit) break; count++; } return sb.toString(); }
/// <summary>Returns a string containing the tokens joined by delimiters.</summary> /// <remarks>Returns a string containing the tokens joined by delimiters.</remarks> /// <param name="tokens"> /// an array objects to be joined. Strings will be formed from /// the objects by calling object.toString(). /// </param> public static string join (CharSequence delimiter, Iterable<CharSequence> tokens) { StringBuilder sb = new StringBuilder (); bool firstTime = true; foreach (object token in Sharpen.IterableProxy.Create(tokens)) { if (firstTime) { firstTime = false; } else { sb.append (delimiter); } sb.append (token); } return sb.ToString (); }
public static Com.Drew.Metadata.Metadata ReadMetadata(FilePath file, Iterable<JpegSegmentMetadataReader> readers) { InputStream inputStream = null; try { inputStream = new FileInputStream(file); return ReadMetadata(inputStream, readers); } finally { if (inputStream != null) { inputStream.Close(); } } }
public static JpegSegmentData ReadSegments(FilePath file, Iterable<JpegSegmentType> segmentTypes) { FileInputStream stream = null; try { stream = new FileInputStream(file); return ReadSegments(new Com.Drew.Lang.StreamReader(stream), segmentTypes); } finally { if (stream != null) { stream.Close(); } } }
public bool load(IFile file) { if (file.exists()) { try { var libraries = new ArrayList<ProjectLibrary>(); var preprocessorSymbols = new HashSet<String>(); var outputPath = "bin"; var document = XmlHelper.load(new InputStreamReader(file.getContents())); var nodeList = document.getElementsByTagName("library"); int length = nodeList.getLength(); for (int i = 0; i < length; i++) { var e = (Element)nodeList.item(i); var lib = new ProjectLibrary(e.getAttribute("name")); var enabled = e.getAttribute("enabled"); lib.setEnabled(enabled.length() == 0 || !enabled.equals("false")); libraries.add(lib); } nodeList = document.getElementsByTagName("preprocessorSymbols"); if (nodeList.getLength() == 1) { foreach (var s in nodeList.item(0).getTextContent().split(";")) { preprocessorSymbols.add(s.trim()); } } nodeList = document.getElementsByTagName("outputPath"); if (nodeList.getLength() == 1) { outputPath = nodeList.item(0).getTextContent(); } this.Libraries = libraries; this.PreprocessorSymbols = preprocessorSymbols; this.OutputPath = outputPath; return true; } catch (Exception e) { Environment.logException(e); } } this.Libraries = Query.empty<ProjectLibrary>(); this.PreprocessorSymbols = Query.empty<String>(); return false; }
public static Iterable<IFile> getModifiedFiles(IResourceDelta delta, Iterable<String> extensions, Iterable<String> excludedFolders) { var result = new HashSet<IFile>(); try { delta.accept(p => { var resource = p.getResource(); switch (resource.getType()) { case IResource.FOLDER: return !excludedFolders.contains(resource.getProjectRelativePath().toPortableString()); case IResource.FILE: var file = (IFile)resource; if (extensions.contains(file.getFileExtension())) { //if ((p.getFlags() & IResourceDelta.CONTENT) != 0 || (p.getFlags() & IResourceDelta.MARKERS) == 0) { result.add(file); //} } return false; } return true; }); } catch (CoreException e) { Environment.logException(e); } return result; }
public static void m(Iterable<string> s) { var query = s.groupBy(e => e.Length); }
public static void m(Iterable <string> s) { var query = s.select(e => new { e, x = e.Length }).select(query$id0 => query$id0.e + query$id0.x); }
public static void m(Iterable<string> s1, Iterable<string> s2) { var query = from e1 in s1 join e2 in s2 on e1.Length equals e2.Length into g select e1 + g.first(); }
internal static Iterable <U> lazyFilter <T, U>(Iterable <T> iterable, System.Type type) { var enumerable = FromJava.IterableToEnumerable(iterable).OfType <U>(); return(ToJava.EnumerableToIterable(enumerable)); }
private void setMethodConstraints(Iterable<TypeParameterConstraintsClauseNode> constraintClauses, MethodBuilder methodBuilder) { var packageName = methodBuilder.DeclaringType.PackageName; foreach (var constraint in constraintClauses) { var name = context.getIdentifier(constraint.NameOffset, constraint.NameLength); var bound = CompilerHelper.resolveTypeReference(context, packageName, constraint.Constraints[0]); if (bound.IsFinal) { context.addError(CompileErrorId.ConstraintNotInterfaceOrFinal, constraint.Constraints[0], BytecodeHelper.getDisplayName(bound)); } methodBuilder.addGenericConstraint(name, bound); for (int i = 1; i < constraint.Constraints.size(); i++) { bound = CompilerHelper.resolveTypeReference(context, packageName, constraint.Constraints[i]); if (!bound.IsInterface || bound.IsFinal) { context.addError(CompileErrorId.ConstraintNotInterfaceOrFinal, constraint.Constraints[i], BytecodeHelper.getDisplayName(bound)); } methodBuilder.addGenericConstraint(name, bound); } } }
/// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Errors.MissingObjectException"></exception> public void SelectObjectRepresentation(PackWriter packer, ProgressMonitor monitor , Iterable<ObjectToPack> objects) { foreach (ObjectToPack otp in objects) { db.SelectObjectRepresentation(packer, otp, this); monitor.Update(1); } }
public static void m(Iterable <Customers> customers) { var query = customers.join(orders, c => c.CustomerID, o => o.CustomerID, (c, o) => new { c, o }).join(details, query$id0 => query$id0.o.OrderID, d => d.OrderID, (query$id0, d) => new { query$id0, d }).join(products, query$id1 => query$id1.d.ProductID, p => p.ProductID, (query$id1, p) => new { query$id1.query$id0.c.Name, query$id1.query$id0.o.OrderDate, p.ProductName });
public IteradorDeColeccionMultiple(Iterable coleccion) { this.coleccion = (ColeccionMultiple)coleccion; this.dePila = new IteradorDePila(this.coleccion.pila); this.deCola = new IteradorDeCola(this.coleccion.cola); }
public static void m(Iterable <string> s1, Iterable <string> s2) { var query = s1.join(s2, e1 => e1.Length, e2 => e2.Length, (e1, e2) => new { e1, e2 }).where (query$id0 => query$id0.e2.Length > 1).select(query$id0 => query$id0.e1 + query$id0.e2); }
static void Main(string[] args) { FileRepositoryBuilder builder = new FileRepositoryBuilder(); Repository repository = builder.SetGitDir(new FilePath(@"D:\Personal\E Books\Higher Education\Research\SampleProjects\NopCommerce\.git")) //Repository repository = builder.SetGitDir(new FilePath(@"C:\Users\neemathu\Documents\GitHub\angular.js\.git")) // Repository repository = builder.SetGitDir(new FilePath(@"D:\Personal\E Books\Higher Education\RefactoringActivity\ganttproject\.git")) .ReadEnvironment() // scan environment GIT_* variables .FindGitDir() // scan up the file system tree .Build(); HashSet <String> uniqueFile = new HashSet <string>(); Dictionary <String, int> logicalCoupling = new Dictionary <string, int>(); RevWalk rw = new RevWalk(repository); Git git = new Git(repository); Iterable <RevCommit> log = git.Log().Call(); for (Iterator <RevCommit> iterator = log.Iterator(); iterator.HasNext();) { RevCommit rev = iterator.Next(); //RevWalk revWalk = new RevWalk(git.GetRepository()); //RevTree revTree = revWalk.ParseTree(rev.Tree.Id); //TreeWalk treeWalk = new TreeWalk(git.GetRepository()); //treeWalk.AddTree(revTree); //while (treeWalk.Next()) //{ // //compare treeWalk.NameString yourself // byte[] bytes = treeWalk.ObjectReader.Open(treeWalk.GetObjectId(0)).GetBytes(); // string result1 = System.Text.Encoding.UTF8.GetString(bytes); //} // Sharpen.OutputStream os = new Sharpen.OutputStream(); //rev.CopyRawTo(os); //System.Console.WriteLine("Author: "+rev.GetAuthorIdent().GetName()); //System.Console.WriteLine("ID:" + rev.Id); var dt = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddSeconds(rev.CommitTime).ToLocalTime(); //var ts = new TimeSpan(DateTime.UtcNow.Ticks - rev.CommitTime); //System.Console.WriteLine("Date:" + dt.ToString()); //System.Console.WriteLine("Description:" + rev.GetFullMessage()); DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE); df.SetRepository(repository); df.SetDiffComparator(RawTextComparator.DEFAULT); df.SetDetectRenames(true); List <String> files = new List <string>(); if (rev.ParentCount > 0) { List <DiffEntry> diffs = df.Scan(rev.GetParent(0).Tree, rev.Tree).ToList(); foreach (DiffEntry diff in diffs) { // Fetch data from the commited new file //ObjectLoader loader = repository.Open(diff.GetNewId().ToObjectId()); //OutputStream @out = new ByteArrayOutputStream(); ////loader.CopyTo(@out); ////Fetch diffrence of commit //DiffCommand diff1 = git.Diff().SetPathFilter(PathFilter.Create(diff.GetNewPath())).SetOldTree(GetTreeIterator(rev.GetParent(0).Tree.Name, repository)).SetNewTree(GetTreeIterator(rev.Tree.Name, repository)).SetOutputStream(@out); //IList<DiffEntry> entries = diff1.Call(); //string data = @out.ToString(); files.Add(diff.GetNewPath()); uniqueFile.Add(diff.GetNewPath()); //System.Console.WriteLine(String.Format("FilePath: {0} {1}", diff.GetNewMode().GetBits(), diff.GetNewPath())); } } if (isContainFile(rev, files)) { //System.Console.WriteLine(rev.Id); //System.Console.WriteLine(dt); //System.Console.WriteLine(rev.GetAuthorIdent().GetName()); //System.Console.WriteLine(rev.GetFullMessage()); tfIdfBeforeData.Add(rev.Id.Name, new Dictionary <string, Dictionary <string, double> >()); foreach (String file in files) { String fileName = file.Substring(file.LastIndexOf("/") + 1, file.Length - file.LastIndexOf("/") - 1); if (IsFileExtentionAllowed(fileName)) { string data = GetCommitDiff(repository, git, rev, file); Dictionary <string, double> tokensTF = GetTokensWithTF(data); tfIdfBeforeData[rev.Id.Name].Add(file, tokensTF); //System.Console.WriteLine("File path: " + file); //System.Console.WriteLine(data); //System.Console.WriteLine("------------------"); if (!logicalCoupling.ContainsKey(fileName)) { logicalCoupling.Add(fileName, 1); } else { logicalCoupling[fileName] += 1; } } } //System.Console.WriteLine("###################################"); } //foreach (var item in uniqueFile) //{ // System.Console.WriteLine(item); //} //System.Console.WriteLine("--------------------"); //http://stackoverflow.com/questions/11869412/jgit-using-revwalk-to-get-revcommit-returns-nothing ////ObjectId head = repository.Resolve("master"); //RevWalk walk = new RevWalk(repository); //foreach (var commit in walk) //{ // String email = commit.GetAuthorIdent().GetEmailAddress(); //} } CalculateTfIdfScore("defaultResources.nopres.xml"); CalculateLogicalDependency(logicalCoupling); System.Console.WriteLine("----------Done----------"); System.Console.ReadLine(); }
static void Main(string[] args) { //string input = "group, and test but not testing. But yes to test"; //string val="Group"; //string pattern = @"\b" + val + @"\b"; //string replace = " "; //string result = System.Text.RegularExpressions.Regex.Replace(input, pattern, replace, System.Text.RegularExpressions.RegexOptions.IgnoreCase); //Console.WriteLine(result); FileRepositoryBuilder builder = new FileRepositoryBuilder(); Repository repository = builder.SetGitDir(new FilePath(@"D:\Personal\E Books\Higher Education\Research\SampleProjects\NopCommerce\.git")) //Repository repository = builder.SetGitDir(new FilePath(@"C:\Users\neemathu\Documents\GitHub\angular.js\.git")) // Repository repository = builder.SetGitDir(new FilePath(@"D:\Personal\E Books\Higher Education\RefactoringActivity\ganttproject\.git")) .ReadEnvironment() // scan environment GIT_* variables .FindGitDir() // scan up the file system tree .Build(); RevWalk rw = new RevWalk(repository); Git git = new Git(repository); Iterable <RevCommit> log = git.Log().Call(); if (args.Length > 0) { switch (args[0]) { case "buildstopwordindex": BuildStopWordIndex(log, repository, git); return; break; default: break; } } // Iterat over revisions for (Iterator <RevCommit> iterator = log.Iterator(); iterator.HasNext();) { RevCommit rev = iterator.Next(); var dt = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddSeconds(rev.CommitTime).ToLocalTime(); DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE); df.SetRepository(repository); df.SetDiffComparator(RawTextComparator.DEFAULT); df.SetDetectRenames(true); List <String> files = new List <string>(); if (rev.ParentCount > 0) { List <DiffEntry> diffs = df.Scan(rev.GetParent(0).Tree, rev.Tree).ToList(); foreach (DiffEntry diff in diffs) { // Fetch data from the commited new file //ObjectLoader loader = repository.Open(diff.GetNewId().ToObjectId()); //OutputStream @out = new ByteArrayOutputStream(); ////loader.CopyTo(@out); ////Fetch diffrence of commit //DiffCommand diff1 = git.Diff().SetPathFilter(PathFilter.Create(diff.GetNewPath())).SetOldTree(GetTreeIterator(rev.GetParent(0).Tree.Name, repository)).SetNewTree(GetTreeIterator(rev.Tree.Name, repository)).SetOutputStream(@out); //IList<DiffEntry> entries = diff1.Call(); //string data = @out.ToString(); string filePath = diff.GetNewPath(); //if (fileCount.ContainsKey(filePath)) //{ // fileCount[filePath] = fileCount[filePath] + 1; //} //else //{ // fileCount.Add(filePath, 1); //} files.Add(filePath); //System.Console.WriteLine(String.Format("FilePath: {0} {1}", diff.GetNewMode().GetBits(), diff.GetNewPath())); } //continue; } if (GitHelper.HasFile(files)) { foreach (String file in files) { String FileName = file.Substring(file.LastIndexOf("/") + 1, file.Length - file.LastIndexOf("/") - 1); if (Utils.AllowedFileExtentions(FileName)) { string DiffContent = GitHelper.GetCommitDiff(repository, git, rev, file); //data = Common.Utils.RemoveStopWords(data); LogicalDependency.LogicalDependency.AddArtifact(rev.Id.Name, file, DiffContent); //StopWords.StopWordIndexBuilder.BuildWordIndex(file, data); } } } } //var sortedElements = fileCount.OrderByDescending(kvp => kvp.Value); //foreach (var item in sortedElements) //{ // Console.WriteLine(item.Key + ": " + item.Value); //} LogicalDependency.LogicalDependency.CalculateSimilarityIndex(); }
/// <exception cref="NGit.Api.Errors.RefNotFoundException"></exception> /// <exception cref="System.IO.IOException"></exception> /// <exception cref="NGit.Api.Errors.NoHeadException"></exception> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> private RebaseResult InitFilesAndRewind() { // we need to store everything into files so that we can implement // --skip, --continue, and --abort Ref head = repo.GetRef(Constants.HEAD); if (head == null || head.GetObjectId() == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , Constants.HEAD)); } string headName; if (head.IsSymbolic()) { headName = head.GetTarget().GetName(); } else { headName = "detached HEAD"; } ObjectId headId = head.GetObjectId(); if (headId == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , Constants.HEAD)); } RevCommit headCommit = walk.LookupCommit(headId); RevCommit upstream = walk.LookupCommit(upstreamCommit.Id); if (walk.IsMergedInto(upstream, headCommit)) { return(RebaseResult.UP_TO_DATE_RESULT); } else { if (walk.IsMergedInto(headCommit, upstream)) { // head is already merged into upstream, fast-foward monitor.BeginTask(MessageFormat.Format(JGitText.Get().resettingHead, upstreamCommit .GetShortMessage()), ProgressMonitor.UNKNOWN); CheckoutCommit(upstreamCommit); monitor.EndTask(); UpdateHead(headName, upstreamCommit); return(RebaseResult.FAST_FORWARD_RESULT); } } monitor.BeginTask(JGitText.Get().obtainingCommitsForCherryPick, ProgressMonitor.UNKNOWN ); // determine the commits to be applied LogCommand cmd = new Git(repo).Log().AddRange(upstreamCommit, headCommit); Iterable <RevCommit> commitsToUse = cmd.Call(); IList <RevCommit> cherryPickList = new AList <RevCommit>(); foreach (RevCommit commit in commitsToUse) { if (commit.ParentCount != 1) { throw new JGitInternalException(JGitText.Get().canOnlyCherryPickCommitsWithOneParent ); } cherryPickList.AddItem(commit); } Sharpen.Collections.Reverse(cherryPickList); // create the folder for the meta information FileUtils.Mkdir(rebaseDir); CreateFile(repo.Directory, Constants.ORIG_HEAD, headId.Name); CreateFile(rebaseDir, REBASE_HEAD, headId.Name); CreateFile(rebaseDir, HEAD_NAME, headName); CreateFile(rebaseDir, ONTO, upstreamCommit.Name); CreateFile(rebaseDir, INTERACTIVE, string.Empty); BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream (new FilePath(rebaseDir, GIT_REBASE_TODO)), Constants.CHARACTER_ENCODING)); fw.Write("# Created by EGit: rebasing " + upstreamCommit.Name + " onto " + headId .Name); fw.NewLine(); try { StringBuilder sb = new StringBuilder(); ObjectReader reader = walk.GetObjectReader(); foreach (RevCommit commit_1 in cherryPickList) { sb.Length = 0; sb.Append(RebaseCommand.Action.PICK.ToToken()); sb.Append(" "); sb.Append(reader.Abbreviate(commit_1).Name); sb.Append(" "); sb.Append(commit_1.GetShortMessage()); fw.Write(sb.ToString()); fw.NewLine(); } } finally { fw.Close(); } monitor.EndTask(); // we rewind to the upstream commit monitor.BeginTask(MessageFormat.Format(JGitText.Get().rewinding, upstreamCommit.GetShortMessage ()), ProgressMonitor.UNKNOWN); bool checkoutOk = false; try { checkoutOk = CheckoutCommit(upstreamCommit); } finally { if (!checkoutOk) { FileUtils.Delete(rebaseDir, FileUtils.RECURSIVE); } } monitor.EndTask(); return(null); }
public void TestIterator() { IEnumerable <EventBean>[][] iterables = new Iterable[1][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "a", "b", "c" })); CheckResults(iterables, EventFactoryHelper.MakeArray(events, new string[] { "a", "b", "c" })); iterables = new Iterable[3][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "a" })); iterables[1] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "b" })); iterables[2] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "c" })); CheckResults(iterables, EventFactoryHelper.MakeArray(events, new string[] { "a", "b", "c" })); iterables = new Iterable[2][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "a", "b" })); iterables[1] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "c" })); CheckResults(iterables, EventFactoryHelper.MakeArray(events, new string[] { "a", "b", "c" })); iterables = new Iterable[5][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[1] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "a", "b" })); iterables[2] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[3] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "c" })); iterables[4] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); CheckResults(iterables, EventFactoryHelper.MakeArray(events, new string[] { "a", "b", "c" })); iterables = new Iterable[1][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); CheckResults(iterables, null); iterables = new Iterable[3][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[1] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[2] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); CheckResults(iterables, null); iterables = new Iterable[4][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[1] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[2] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[3] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "d" })); CheckResults(iterables, EventFactoryHelper.MakeArray(events, new string[] { "d" })); iterables = new Iterable[4][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "d" })); iterables[1] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[2] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[3] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); CheckResults(iterables, EventFactoryHelper.MakeArray(events, new string[] { "d" })); iterables = new Iterable[8][]; iterables[0] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "a", "b", "c" })); iterables[1] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "d" })); iterables[2] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[3] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "e", "f" })); iterables[4] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "g" })); iterables[5] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { })); iterables[6] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "h", "i" })); iterables[7] = MakeArray(EventFactoryHelper.MakeList(events, new string[] { "z" })); CheckResults(iterables, EventFactoryHelper.MakeArray(events, new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "z" })); iterables = new Iterable[0][]; CheckResults(iterables, null); }
public static IEnumerable <Pair <T, T> > AdjacentPairs <T>(this IEnumerable <T> list) { return(Iterable.AdjacentPairs(list.AsIterable())); }
public IteradorDeConjunto(Iterable conjunto) { this.conjunto = (Conjunto)conjunto; this.indice = 0; }
AllContains(Iterable<string> strings) { this.strings = strings; }
//private int indice; public IteradorDeDiccionario(Iterable diccionario) { this.diccionario = (Diccionario)diccionario; this.deConjunto = new IteradorDeConjunto(this.diccionario.Conjunto); //this.indice = 0; }
public ArchiveFileFilter(Iterable <IResource> excludedFiles, bool recursive, bool allowAllArchives) { this.excludedFiles = (excludedFiles == null) ? Query.empty <IResource>() : excludedFiles; this.recursive = recursive; this.allowAllArchives = allowAllArchives; }
public IteradorDePila(Iterable pila) { this.pila = (Pila)pila; this.indice = 0; }
private static String[] getTypeNames(Iterable<TypeInfo> types) { if (types.any()) { String[] result = new String[types.count()]; int i = 0; foreach (var t in types) { result[i++] = t.FullName; } return result; } else { return null; } }
public IteradorDeCola(Iterable cola) { this.cola = (Cola)cola; this.indice = 0; }
public static void m(Iterable<string> s) { var query = s.orderBy(e => e.Length).thenByDescending(e => e); }
public static void m(Iterable <string> s) { var query = from e in s where e.Length > 0 select e; }
public static void Build(SimpleProto builder, IEventArgs args, string key, string img, bool show, bool pvs, string xyz, string scale, string rotaion, Iterable <IFreeEffect> effects, IList <IFreeUIAuto> autos, IPosSelector selector, string size) { builder.Key = 60; builder.Bs.Add(show); builder.Bs.Add(pvs); AddPosition(xyz, scale, rotaion, builder); builder.Ks.Add(1); builder.Ss.Add(key); if (img == null) { builder.Ss.Add(string.Empty); } else { builder.Ss.Add(img); } builder.Ss.Add(GetAutoString(autos, args)); if (StringUtil.IsNullOrEmpty(size)) { builder.Ss.Add(string.Empty); } else { builder.Ss.Add(FreeUtil.ReplaceVar(size, args)); } if (effects != null) { foreach (IFreeEffect com in effects) { builder.Ks.Add(com.GetKey(args)); AddPosition(com.GetXyz(args, selector), com.GetScale(args), com.GetRotation(args, selector), builder); builder.Ss.Add(com.GetStyle(args, key)); builder.Ss.Add(GetAutoString(com.GetAutos(args), args)); } } }
AllContains(Iterable <string> strings) { this.strings = strings; }
public static void m(Iterable<string> s1, Iterable<string> s2) { var query = s1.join(s2, e1 => e1.Length, e2 => e2.Length, (e1, e2) => e1 + e2); }
bool method(Iterable <string> si) { return(si.all(s => strings.contains(s))); }
public static void m(Iterable<string> s) { var query = from e in s let x = e.Length select e + x; }
private SourceCompilerResults compileCore(IProgressMonitor monitor) { var t0 = System.nanoTime(); var results = new SourceCompilerResults(); var hasErrors = false; var errorManager = new CodeErrorManager(); var allFiles = parameters.AllFiles; Iterable <IFile> filesToCompile = null; try { monitor.beginTask("", 11); var deletedFiles = parameters.FilesToCompile .select(p => allFiles.getResource(p)) .where (p => p == null || !p.exists()) .select(p => allFiles.getProjectRelativeName(p)).toSet(); var typesToCopy = Query.empty <TypeInfo>(); // Get the files to compile if (parameters.FullBuild) { filesToCompile = allFiles.getAllResources().where (p => p.exists()).toList(); } else { bool filteringDone = false; var referencingFiles = parameters.getDependencyInfo().getAllReferencingFiles(parameters.getFilesToCompile()); if (parameters.ProgressiveBuild && deletedFiles.isEmpty()) { var referencedFiles = parameters.getDependencyInfo().getAllReferencedFiles(parameters.getFilesToCompile()); referencedFiles = referencedFiles.except(parameters.getFilesToCompile()); referencedFiles = referencedFiles.intersect(referencingFiles); // Progressive build only if referenced and referencing files do not intersect if (!referencedFiles.any()) { filesToCompile = parameters.FilesToCompile.select(p => allFiles.getResource(p)).where (p => p.exists()).toList(); filteringDone = true; } } if (!filteringDone) { // Incremental build with dependencies filesToCompile = referencingFiles.select(p => allFiles.getResource(p)).where (p => p.exists()).toList(); } var filesToKeep = allFiles.getAllProjectRelativeNames().except(referencingFiles); typesToCopy = filesToKeep.selectMany(p => parameters.DependencyInfo.getFileContents(p)) .where (p => p.indexOf('$') == -1).select(p => parameters.TypeSystem.getType(p)); Environment.trace(this, "keeping " + filesToKeep.count() + " files"); Environment.trace(this, "ignoring " + (allFiles.getAllResources().count() - filesToCompile.count() - filesToKeep.count()) + " files"); } Environment.trace(this, "compiling " + filesToCompile.count() + " files"); monitor.worked(1); if (monitor.isCanceled()) { throw new InterruptedException(); } var compilationUnits = new HashMap <String, CompilationUnitNode>(); // Parsing foreach (var file in filesToCompile) { var text = getText(file); if (text != null) { parse(file, text, errorManager, compilationUnits); } } monitor.worked(1); if (monitor.isCanceled()) { throw new InterruptedException(); } // Compiling var t1 = System.nanoTime(); var typeSystem = new Library(parameters.ClassPath); JvmTypeSystemHelper.cloneTypes(typesToCopy, typeSystem); var annotatedTypeSystem = new Library(new[] { Environment.getLibraryPath("stabal.jar") }, typeSystem); var cparams = new CompilerParameters(); cparams.TypeSystem = typeSystem; cparams.AnnotatedTypeSystem = annotatedTypeSystem; cparams.GenerateClassFiles = parameters.GenerateClassFiles; cparams.ProgressTracker = new CompilationProgressTracker(monitor); var cunits = compilationUnits.values().toArray(new CompilationUnitNode[compilationUnits.size()]); var cresults = new StabCompiler().compileFromCompilationUnits(cparams, cunits); Environment.trace(this, "compilation of " + sizeof(cunits) + " files done in " + ((System.nanoTime() - t1) / 1e6) + "ms"); foreach (var error in cresults.Errors) { if (error.Level == 0) { hasErrors = true; } results.CodeErrors.add(error); Environment.trace(this, "error (" + error.Line + ", " + error.Column + ") " + error.Filename + ": " + error.Message); } if (!hasErrors) { var dependencyInfo = new DependencyInfo(); results.DependencyInfo = dependencyInfo; var allTypes = new HashSet <String>(); // Copy informations from unbuilt files if (parameters.DependencyInfo != null) { var unbuiltFiles = allFiles.getAllProjectRelativeNames(); unbuiltFiles = unbuiltFiles.except(filesToCompile.select(p => allFiles.getProjectRelativeName(p))); unbuiltFiles = unbuiltFiles.except(deletedFiles); foreach (var file in unbuiltFiles) { foreach (var type in parameters.DependencyInfo.getFileContents(file)) { allTypes.add(type); dependencyInfo.addFileToTypeRelation(file, type); foreach (var refType in parameters.DependencyInfo.getReferencedTypes(type)) { dependencyInfo.addTypeToTypeRelation(type, refType); } } } } // Collect the types and update the dependencies. var typeMembers = new HashMap <IFile, Iterable <TypeMemberNode> >(); foreach (var file in filesToCompile) { var fileName = allFiles.getProjectRelativeName(file); var compilationUnit = compilationUnits[fileName]; if (compilationUnit == null) { continue; } var members = SyntaxTreeHelper.getTypeMembers(compilationUnit); typeMembers.put(file, members); foreach (var member in members) { var typeName = member.getUserData(typeof(TypeInfo)).FullName; dependencyInfo.addFileToTypeRelation(fileName, typeName); allTypes.add(typeName); } } if (parameters.DependencyInfo != null) { // Copy the types ignored by this compilation var missingTypes = new HashSet <TypeInfo>(); foreach (var t in allTypes.where (p => p.indexOf('$') == -1 && !typeSystem.typeExists(p))) { if (hasErrors = !parameters.DependencyInfo.getReferencedTypes(t).all(p => allTypes.contains(p))) { Environment.trace(this, "Incremental build failed: a type was deleted"); break; } missingTypes.add(parameters.TypeSystem.getType(t)); } if (!hasErrors) { JvmTypeSystemHelper.cloneTypes(missingTypes, typeSystem); } } if (!hasErrors) { // Compute the dependencies in the compiled files foreach (var member in filesToCompile.select(p => typeMembers[p]).where (p => p != null).selectMany(p => p)) { foreach (var t in SyntaxTreeHelper.getTypeMemberDependencies(member) .intersect(allTypes.select(p => JvmTypeSystemHelper.getType(typeSystem, p)))) { dependencyInfo.addTypeToTypeRelation(member.getUserData(typeof(TypeInfo)).FullName, t.FullName); } } results.TypeSystem = typeSystem; results.AnnotatedTypeSystem = annotatedTypeSystem; foreach (var e in compilationUnits.entrySet()) { results.CompilationUnits[e.Key] = e.Value; } foreach (var e in cresults.ClassFiles.entrySet()) { results.ClassFiles[e.Key] = e.Value; } } } monitor.worked(1); } catch (CodeErrorException e) { monitor.worked(10); } catch (TypeLoadException e) { results.MissingType = e.TypeName; hasErrors = true; monitor.worked(6); } finally { monitor.done(); } foreach (var file in filesToCompile) { results.CompiledFiles.add(allFiles.getProjectRelativeName(file)); } foreach (var error in errorManager.Errors) { if (error.Level == 0) { hasErrors = true; } results.CodeErrors.add(error); Environment.trace(this, "error (" + error.Line + ", " + error.Column + ") " + error.Filename + ": " + error.Message); } results.Failed = hasErrors; Environment.trace(this, "compilation done in " + ((System.nanoTime() - t0) / 1e6) + "ms"); return(results); }
private Iterable<MemberInfo> filterMembers(TypeInfo scope, bool staticOnly, Iterable<MemberInfo> members) { foreach (var mi in members) { if (mi.MemberKind == MemberKind.Local || mi.DeclaringType == null) { yield return mi; } else { if (staticOnly && !mi.IsStatic) { continue; } if (!scope.canAccessMember(mi.DeclaringType, mi.IsPublic, mi.IsProtected, mi.IsPrivate)) { continue; } yield return mi; } } }
/// <summary> /// Returns an iterable which filters the given iterable based on this /// filter. /// </summary> /// <remarks> /// Returns an iterable which filters the given iterable based on this /// filter. /// </remarks> /// <param name="iterable">row iterable to filter</param> /// <returns>a filtering iterable</returns> public virtual Iterable <IDictionary <string, object> > Apply(Iterable <IDictionary <string , object> > iterable) { return(new RowFilter.FilterIterable(this, iterable)); }
public void enterPackage(Iterable<String> names, PackageBodyNode body) { packageNames = packageNames.concat(names); packageInfos.add(body.getUserData(typeof(PackageInfo))); }
internal FilterIterable(RowFilter _enclosing, Iterable <IDictionary <string, object> > iterable) { this._enclosing = _enclosing; this._iterable = iterable; }
bool method(Iterable<string> si) { return si.all(s => strings.contains(s)); }
/// <exception cref="Com.Drew.Imaging.Jpeg.JpegProcessingException"/> /// <exception cref="System.IO.IOException"/> public static void Process(Com.Drew.Metadata.Metadata metadata, InputStream inputStream, Iterable <JpegSegmentMetadataReader> readers) { if (readers == null) { readers = AllReaders; } ICollection <JpegSegmentType> segmentTypes = new HashSet <JpegSegmentType>(); foreach (JpegSegmentMetadataReader reader in readers) { foreach (JpegSegmentType type in reader.GetSegmentTypes()) { segmentTypes.Add(type); } } JpegSegmentData segmentData = JpegSegmentReader.ReadSegments(new Com.Drew.Lang.StreamReader(inputStream), segmentTypes.AsIterable()); ProcessJpegSegmentData(metadata, readers, segmentData); }
private void replaceCref(Element element, bool exception, Iterable<MemberInfo> members, String suffix, String arguments) { if (members.count() > 1 && !members.all(p => p.MemberKind == MemberKind.Method)) { context.addWarning(CompileErrorId.UnresolvedCref, node, element.getAttribute("cref")); element.setAttribute("cref", "!" + element.getAttribute("cref")); return; } var member = members.first(); switch (member.MemberKind) { case Type: replaceCref(element, exception, member.Type, suffix, arguments); break; case Field: if (exception) { context.addWarning(CompileErrorId.ExpectedExceptionInCref, node, element.getAttribute("cref")); element.setAttribute("cref", "!" + element.getAttribute("cref")); return; } if (suffix != null || arguments != null) { context.addWarning(CompileErrorId.UnresolvedCref, node, element.getAttribute("cref")); element.setAttribute("cref", "!" + element.getAttribute("cref")); return; } element.setAttribute("cref", getIdString(member.Field)); break; case Property: if (exception) { context.addWarning(CompileErrorId.ExpectedExceptionInCref, node, element.getAttribute("cref")); element.setAttribute("cref", "!" + element.getAttribute("cref")); return; } if (suffix != null || arguments != null) { context.addWarning(CompileErrorId.UnresolvedCref, node, element.getAttribute("cref")); element.setAttribute("cref", "!" + element.getAttribute("cref")); return; } element.setAttribute("cref", getIdString(member.GetAccessor ?? member.SetAccessor)); break; case Method: if (!exception && suffix == null) { if (arguments == null && members.count() == 1) { element.setAttribute("cref", getIdString(member.Method)); return; } else if (arguments != null && arguments.endsWith(")")) { var args = new ArrayList<TypeInfo>(); if (arguments.length() > 2) { arguments = arguments.substring(1, arguments.length() - 1); int idx; while ((idx = arguments.indexOf(',')) != -1) { var name = arguments.substring(0, idx); arguments = arguments.substring(idx + 1); var type = getType(name); if (type == null) { goto failed; } args.add(type); } if (arguments.length() == 0) { goto failed; } var type = getType(arguments); if (type == null) { goto failed; } args.add(type); } foreach (var m in members) { if (m.Method.Parameters.select(p => p.Type).sequenceEqual(args)) { element.setAttribute("cref", getIdString(m.Method)); return; } } } } failed: context.addWarning(CompileErrorId.UnresolvedCref, node, element.getAttribute("cref")); element.setAttribute("cref", "!" + element.getAttribute("cref")); break; default: break; } }
public static void ProcessJpegSegmentData(Com.Drew.Metadata.Metadata metadata, Iterable <JpegSegmentMetadataReader> readers, JpegSegmentData segmentData) { // Pass the appropriate byte arrays to each reader. foreach (JpegSegmentMetadataReader reader in readers) { foreach (JpegSegmentType segmentType in reader.GetSegmentTypes()) { foreach (sbyte[] segmentBytes in segmentData.GetSegments(segmentType)) { if (reader.CanProcess(segmentBytes, segmentType)) { reader.Extract(segmentBytes, metadata, segmentType); } } } } }
public static void m(Iterable<string> s1, Iterable<string> s2) { var query = from e1 in s1 from e2 in s2 select e1 + e2; }
public static Com.Drew.Metadata.Metadata ReadMetadata(InputStream inputStream, Iterable <JpegSegmentMetadataReader> readers) { Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata(); Process(metadata, inputStream, readers); return(metadata); }
/// <exception cref="System.IO.IOException"></exception> public void WriteObjects(PackOutputStream @out, Iterable<ObjectToPack> list) { foreach (ObjectToPack otp in list) { @out.WriteObject(otp); } }
public static void m(Iterable <string> s) { var query = from e in s let x = e.Length select e + x; }
public static void m(Iterable<string> s) { var query = from string e in s select e; }
/// <summary> /// Returns an iterable which filters the given iterable based on the given /// rowFilter. /// </summary> /// <remarks> /// Returns an iterable which filters the given iterable based on the given /// rowFilter. /// </remarks> /// <param name="rowFilter"> /// the filter criteria, may be /// <code>null</code> /// </param> /// <param name="iterable">row iterable to filter</param> /// <returns> /// a filtering iterable (or the given iterable if a /// <code>null</code> /// filter was given) /// </returns> public static Iterable <IDictionary <string, object> > Apply(RowFilter rowFilter, Iterable <IDictionary <string, object> > iterable) { return((rowFilter != null) ? rowFilter.Apply(iterable) : iterable); }
public void initialize(Iterable<String> stringIDs) { for (String stringID : stringIDs) { storeMapping(tolongID(stringID), stringID); } }
static void Main(string[] args) { Iterable <RevCommit> gitLogs = GetRevCommitList(); int count = 0; DateTime startTime = System.DateTime.Now; Dictionary <string, string> gitLogDictionary = new Dictionary <string, string>(); Dictionary <string, Dictionary <string, string> > groupedChangeSets = new Dictionary <string, Dictionary <string, string> >(); HashSet <string> commitIDs = new HashSet <string>(); for (Iterator <RevCommit> iterator = gitLogs.Iterator(); iterator.HasNext();) { RevCommit rev = iterator.Next(); //System.Console.WriteLine(rev.Id.FirstByte); //System.Console.WriteLine(rev.GetFullMessage()); // TermFrequency.Add(rev.Id.Name, rev.GetFullMessage()); gitLogDictionary.Add(rev.Id.Name, TermFrequency.CleanInput(rev.GetFullMessage())); //System.Console.ReadLine(); count++; } int loopCount = 0; Iterable <RevCommit> gitLogs1 = GetRevCommitList(); //for (Iterator<RevCommit> iterator2 = gitLogs1.Iterator(); iterator2.HasNext(); ) foreach (var itemParent in gitLogDictionary) { //RevCommit rev = iterator2.Next(); bool first = true; if (!itemParent.Value.ToLower().Contains("merge branch") && !commitIDs.Contains(itemParent.Key)) { foreach (var item in gitLogDictionary) { if (!item.Value.ToLower().Contains("merge branch")) { if (item.Key != itemParent.Key && TermFrequency.GetSimilarityValue(itemParent.Value, item.Value) > 0.8) { if (first) { groupedChangeSets.Add(itemParent.Key, new Dictionary <string, string>() { { itemParent.Key, itemParent.Value } }); commitIDs.Add(itemParent.Key); first = false; } groupedChangeSets[itemParent.Key].Add(item.Key, item.Value); commitIDs.Add(item.Key); string Test1 = "1"; } } } } loopCount++; System.Console.Clear(); System.Console.WriteLine(loopCount); } TimeSpan TotalTime = (System.DateTime.Now - startTime); foreach (var item in groupedChangeSets) { foreach (var item1 in item.Value) { //System.Console.WriteLine(item.Key + ";" + item1.Key + ";" + item1.Value); WriteData(item.Key, item1.Key, item1.Value); } } System.Console.WriteLine(TotalTime); // System.Console.ReadLine(); //TermFrequency.Print(); }
public static void m(Iterable <string> s1, Iterable <string> s2) { var query = from e1 in s1 join e2 in s2 on e1.Length equals e2.Length into g select e1 + g.first(); }
internal static Iterable <T> lazyFilter <T>(Iterable <T> iterable, Predicate <T> predicate) { var enumerable = FromJava.IterableToEnumerable(iterable).Where(predicate.test); return(ToJava.EnumerableToIterable(enumerable)); }