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));
}
