public override void FinalizeProject(Variables.Root variables)
{
base.FinalizeProject(variables);
variables.Average(Key + "LinesAvg", Key + "LinesTotal", Key + "CodeFiles");
variables.Average(Key + "CharsAvg", Key + "CharsTotal", Key + "CodeFiles");
variables.Average(Key + "CharsPerLineAvg", Key + "CharsTotal", Key + "LinesTotal");
State state = variables.GetStateObject <State>(stateOwner);
foreach (FileIntValue fi in state.MaxLines)
{
variables.AddToArray(Key + "LinesTop", GetFileObject(fi, variables));
}
foreach (FileIntValue fi in state.MinLines.Reverse())
{
variables.AddToArray(Key + "LinesBottom", GetFileObject(fi, variables));
}
foreach (FileIntValue fi in state.MaxChars)
{
variables.AddToArray(Key + "CharsTop", GetFileObject(fi, variables));
}
foreach (FileIntValue fi in state.MinChars.Reverse())
{
variables.AddToArray(Key + "CharsBottom", GetFileObject(fi, variables));
}
}
public override IEnumerable <Node> GenerateTreeViewData(Variables.Root variables, File file)
{
JavaFileInfo info = variables.GetStateObject <JavaState>(this).GetFile(file);
foreach (Type type in info.Types)
{
yield return(GenerateTreeViewDataForType(info, type));
}
}
public static void Maximum(this Variables.Root variables, string name, int nextValue)
{
int currentValue = variables.GetVariable(name, int.MinValue);
if (nextValue > currentValue)
{
variables.SetVariable(name, nextValue);
}
}
public override void Process(File file, Variables.Root variables)
{
base.Process(file, variables);
variables.Increment("fileTypeCode");
variables.Increment(Key + "CodeFiles");
ProcessFileContents(file, variables);
}
private static Variables.Root GenerateVariables(File file)
{
AbstractLanguageFileHandler handler = GetLanguageHandler(file);
Variables.Root variables = new Variables.Root();
handler.SetupProject(variables);
handler.Process(file, variables);
handler.FinalizeProject(variables);
return variables;
}
private static Variables.Root GenerateVariables(File file)
{
AbstractLanguageFileHandler handler = GetLanguageHandler(file);
Variables.Root variables = new Variables.Root();
handler.SetupProject(variables);
handler.Process(file, variables);
handler.FinalizeProject(variables);
return(variables);
}
private void btnDebug_Click(object sender, EventArgs e)
{
RelativeFile item = listBoxFiles.SelectedItem as RelativeFile;
if (item == null)
{
return;
}
Variables.Root variables = GenerateVariables(item.File);
variables.CheckFlag(""); // keep the object alive for debugging
Debugger.Break();
}
public override void Process(File file, Variables.Root variables)
{
base.Process(file, variables);
JavaState state = variables.GetStateObject <JavaState>(this);
JavaFileInfo info = state.Process(file);
variables.Increment("javaImportsTotal", info.Imports.Count);
variables.Maximum("javaImportsMax", info.Imports.Count);
foreach (Type type in info.Types)
{
ProcessType(info.Package, type, variables, false);
}
}
public override void FinalizeProject(Variables.Root variables)
{
base.FinalizeProject(variables);
State state = variables.GetStateObject <State>(this);
state.TypeEntry.UpdateVariable("value", state.Count);
KeyValuePair <long, string> size = IOUtils.GetFriendlyFileSize(state.Size);
state.SizeEntry.UpdateVariable("size", (int)size.Key);
state.SizeEntry.UpdateVariable("units", size.Value);
state.SizeEntry.UpdateVariable("compl", (int)(state.Size & ((1L << 32) - 1L)));
state.SizeEntry.UpdateVariable("comph", (int)(state.Size >> 32));
}
public override void Process(File file, Variables.Root variables)
{
base.Process(file, variables);
variables.Increment("fileTypeAssets");
State state = variables.GetStateObject <State>(this);
if (++state.Count == 1)
{
variables.SetArraySorter("assetTypes", AssetRowSorter);
state.TypeEntry = variables.AddToArray("assetTypes", new { title = GetAssetTypeName(type), value = 0 });
variables.SetArraySorter("assetSizes", AssetSizeRowSorter);
state.SizeEntry = variables.AddToArray("assetSizes", new { title = GetAssetTypeName(type), compl = 0, comph = 0, size = 0, units = "" });
}
state.Size += file.SizeInBytes;
}
protected virtual void ProcessFileContents(File file, Variables.Root variables)
{
string[] contents = file.Contents.Split('\n');
int lineCount = 0, charCount = 0, maxCharsPerLine = 0;
foreach (string line in contents)
{
if (!line.Trim().Equals("{"))
{
++lineCount;
}
if (line.Length > 0)
{
int realLength = ParseUtils.CountCharacters(line);
charCount += realLength;
maxCharsPerLine = Math.Max(maxCharsPerLine, realLength);
}
}
variables.Increment(Key + "LinesTotal", lineCount);
variables.Increment(Key + "CharsTotal", charCount);
variables.Maximum(Key + "LinesMax", lineCount);
variables.Maximum(Key + "CharsMax", charCount);
variables.Maximum(Key + "CharsPerLineMax", maxCharsPerLine);
State state = variables.GetStateObject <State>(stateOwner);
FileIntValue fileLines = new FileIntValue(file, lineCount);
state.MaxLines.Add(fileLines);
state.MinLines.Add(fileLines);
FileIntValue fileChars = new FileIntValue(file, charCount);
state.MaxChars.Add(fileChars);
state.MinChars.Add(fileChars);
}
public virtual void FinalizeProject(Variables.Root variables)
{
}
public virtual void SetupProject(Variables.Root variables)
{
}
public void ProcessAsync()
{
var task = new Task(() => {
var variables = new Variables.Root();
int processedEntries = 0, totalEntries = SearchData.EntryCount;
int processedWeight = 0, totalWeight = HandlerList.GetTotalWeight(SearchData);
int updateCounter = 0, updateInterval = totalEntries / 400;
if (Progress != null)
{
Progress(0, processedEntries, totalEntries);
}
Action checkProgress;
if (Progress != null)
{
checkProgress = () => {
if (++updateCounter > updateInterval && Progress != null)
{
updateCounter = 0;
Progress((int)Math.Floor(100F * processedWeight / totalWeight), processedEntries, totalEntries);
}
};
}
else
{
checkProgress = () => {};
}
// Folders
List <IFolderHandler> folderHandlers = HandlerList.GetFolderHandlers().ToList();
int folderHandlerWeight = folderHandlers.Sum(handler => handler.Weight);
foreach (string folder in SearchData.Folders)
{
if (cancelToken.IsCancellationRequested)
{
if (CancelFinish != null)
{
CancelFinish();
}
return;
}
foreach (IFolderHandler folderHandler in folderHandlers)
{
folderHandler.Process(folder, variables);
}
++processedEntries;
++updateCounter;
processedWeight += folderHandlerWeight;
checkProgress();
}
// Files
HashSet <IFileHandler> initializedHandlers = new HashSet <IFileHandler>();
foreach (File file in SearchData.Files)
{
if (cancelToken.IsCancellationRequested)
{
if (CancelFinish != null)
{
CancelFinish();
}
return;
}
IFileHandler handler = HandlerList.GetFileHandler(file);
if (initializedHandlers.Add(handler))
{
handler.SetupProject(variables);
}
handler.Process(file, variables);
++processedEntries;
++updateCounter;
processedWeight += handler.Weight;
checkProgress();
}
foreach (IFileHandler handler in initializedHandlers)
{
handler.FinalizeProject(variables);
}
// Finalize
if (Progress != null)
{
Progress(100, processedEntries, totalEntries);
}
if (Finish != null)
{
Finish(variables);
}
}, cancelToken.Token);
task.ContinueWith(originalTask => {
if (Failure != null)
{
Failure(originalTask.Exception);
}
}, TaskContinuationOptions.OnlyOnFaulted);
task.Start();
}
public virtual void Process(File file, Variables.Root variables)
{
variables.Increment("dirStructureFiles");
}
public static void Percent(this Variables.Root variables, string targetName, string totalValueName, string unitValueName)
{
int val = (int)Math.Round(100.0 * variables.GetVariable(totalValueName, 0) / Math.Max(1, variables.GetVariable(unitValueName, 1)));
variables.SetVariable(targetName, val);
}
private void ProcessType(string prefix, Type type, Variables.Root variables, bool isNested)
{
foreach (Type nestedType in type.NestedTypes)
{
ProcessType(prefix + "." + type.Identifier, nestedType, variables, true);
}
// declaration type
variables.Increment("javaTypesTotal");
string declPrefix = "javaUnknown";
switch (type.Declaration)
{
case Type.DeclarationType.Class: variables.Increment(declPrefix = "javaClasses"); break;
case Type.DeclarationType.Interface: variables.Increment(declPrefix = "javaInterfaces"); break;
case Type.DeclarationType.Enum: variables.Increment(declPrefix = "javaEnums"); break;
case Type.DeclarationType.Annotation: variables.Increment(declPrefix = "javaAnnotations"); break;
}
if (isNested)
{
variables.Increment(declPrefix + (type.Modifiers.HasFlag(Modifiers.Static) ? "NestedStatic" : "NestedInner"));
}
foreach (Modifiers modifier in JavaModifiers.Values.Where(modifier => type.Modifiers.HasFlag(modifier)))
{
variables.Increment(declPrefix + JavaModifiers.ToString(modifier).CapitalizeFirst());
}
// identifier
TypeIdentifier identifier = new TypeIdentifier(prefix, type.Identifier);
int simpleNameLength = identifier.Name.Length;
variables.Increment("javaNamesSimpleTotal", simpleNameLength);
variables.Minimum("javaNamesSimpleMin", simpleNameLength);
variables.Maximum("javaNamesSimpleMax", simpleNameLength);
int fullLength = identifier.FullName.Length;
variables.Increment("javaNamesFullTotal", fullLength);
variables.Minimum("javaNamesFullMin", fullLength);
variables.Maximum("javaNamesFullMax", fullLength);
JavaGlobalInfo global = variables.GetStateObject <JavaState>(this).GlobalInfo;
global.IdentifiersSimpleTop.Add(identifier);
global.IdentifiersSimpleBottom.Add(identifier);
global.IdentifiersFullTop.Add(identifier);
global.IdentifiersFullBottom.Add(identifier);
if (type.Declaration == Type.DeclarationType.Annotation)
{
// annotation elements
int methodCount = type.GetData().Methods.Count;
variables.Increment("javaAnnotationsElementsTotal", methodCount);
variables.Minimum("javaAnnotationsElementsMin", methodCount);
variables.Maximum("javaAnnotationsElementsMax", methodCount);
}
else
{
// fields
List <Field> fields = type.GetData().Fields;
int fieldsDefault = fields.Count;
variables.Increment(declPrefix + "FieldsTotal", fields.Count);
variables.Minimum(declPrefix + "FieldsMin", fields.Count);
variables.Maximum(declPrefix + "FieldsMax", fields.Count);
foreach (Modifiers modifier in JavaModifiers.Values)
{
int count = fields.Count(field => field.Modifiers.HasFlag(modifier));
if (modifier == Modifiers.Public || modifier == Modifiers.Protected || modifier == Modifiers.Private)
{
fieldsDefault -= count;
}
variables.Increment(declPrefix + "Fields" + JavaModifiers.ToString(modifier).CapitalizeFirst(), count);
}
variables.Increment(declPrefix + "FieldsDefaultVisibility", fieldsDefault);
// methods
List <Method> constructorMethods = type.GetData().Methods.Where(method => method.IsConstructor).ToList();
List <Method> classMethods = type.GetData().Methods.Where(method => !method.IsConstructor).ToList();
int methodsDefault = classMethods.Count;
if (type.GetData().CanHaveConstructors)
{
variables.Increment(declPrefix + "ConstructorsTotal", Math.Max(1, constructorMethods.Count)); // if 0, count an implicit constructor
}
variables.Increment(declPrefix + "MethodsTotal", classMethods.Count);
variables.Minimum(declPrefix + "MethodsMin", classMethods.Count);
variables.Maximum(declPrefix + "MethodsMax", classMethods.Count);
foreach (Modifiers modifier in JavaModifiers.Values)
{
int count = classMethods.Count(method => method.Modifiers.HasFlag(modifier));
if (modifier == Modifiers.Public || modifier == Modifiers.Protected || modifier == Modifiers.Protected)
{
methodsDefault -= count;
}
variables.Increment(declPrefix + "Methods" + JavaModifiers.ToString(modifier).CapitalizeFirst(), count);
}
variables.Increment(declPrefix + "MethodsDefaultVisibility", methodsDefault);
}
// enums
if (type.Declaration == Type.DeclarationType.Enum)
{
Type.DataEnum enumData = type.GetData <Type.DataEnum>();
variables.Increment("javaEnumsValuesTotal", enumData.EnumValues.Count);
variables.Minimum("javaEnumsValuesMin", enumData.EnumValues.Count);
variables.Maximum("javaEnumsValuesMax", enumData.EnumValues.Count);
}
// annotations
variables.Increment("javaAnnotationsUsedClasses", type.Annotations.Count);
foreach (Field field in type.GetData().Fields)
{
variables.Increment("javaAnnotationsUsedFields", field.Annotations.Count);
}
foreach (Method method in type.GetData().Methods)
{
variables.Increment("javaAnnotationsUsedMethods", method.Annotations.Count);
}
// field and method counting
variables.Increment("javaFieldsTotal", type.GetData().Fields.Count);
variables.Increment("javaMethodsTotal", type.GetData().Methods.Count);
foreach (Method method in type.GetData().Methods)
{
variables.Increment("javaMethodParametersTotal", method.ParameterTypes.Count);
variables.Minimum("javaMethodParametersMin", method.ParameterTypes.Count);
variables.Maximum("javaMethodParametersMax", method.ParameterTypes.Count);
}
}
public static void Average(this Variables.Root variables, string targetName, string totalValueName, string unitValueName, int roundingThreshold = 10)
{
float avg = (float)variables.GetVariable(totalValueName, 0) / Math.Max(1, variables.GetVariable(unitValueName, 1));
variables.SetVariable(targetName, avg >= roundingThreshold ? (int)Math.Round(avg) : avg);
}
public override void SetupProject(Variables.Root variables)
{
base.SetupProject(variables);
variables.AddFlag(Key);
variables.AddStateObject(stateOwner, new State());
}
public override void FinalizeProject(Variables.Root variables)
{
base.FinalizeProject(variables);
JavaState state = variables.GetStateObject <JavaState>(this);
JavaGlobalInfo global = state.GlobalInfo;
// general
variables.SetVariable("javaPackages", state.PackageCount);
// imports
variables.Average("javaImportsAvg", "javaImportsTotal", "javaCodeFiles");
variables.Average("javaNamesSimpleAvg", "javaNamesSimpleTotal", "javaTypesTotal");
variables.Average("javaNamesFullAvg", "javaNamesFullTotal", "javaTypesTotal");
// identifiers
foreach (TypeIdentifier identifier in global.IdentifiersSimpleTop)
{
variables.AddToArray("javaNamesSimpleTop", new { package = identifier.Prefix, name = identifier.Name });
}
foreach (TypeIdentifier identifier in global.IdentifiersSimpleBottom.Reverse())
{
variables.AddToArray("javaNamesSimpleBottom", new { package = identifier.Prefix, name = identifier.Name });
}
foreach (TypeIdentifier identifier in global.IdentifiersFullTop)
{
variables.AddToArray("javaNamesFullTop", new { package = identifier.Prefix, name = identifier.Name });
}
foreach (TypeIdentifier identifier in global.IdentifiersFullBottom.Reverse())
{
variables.AddToArray("javaNamesFullBottom", new { package = identifier.Prefix, name = identifier.Name });
}
// fields and methods
variables.Average("javaClassesFieldsAvg", "javaClassesFieldsTotal", "javaClasses");
variables.Average("javaClassesConstructorsAvg", "javaClassesConstructorsTotal", "javaClasses");
variables.Average("javaClassesMethodsAvg", "javaClassesMethodsTotal", "javaClasses");
variables.Average("javaInterfacesFieldsAvg", "javaInterfacesFieldsTotal", "javaInterfaces");
variables.Average("javaInterfacesMethodsAvg", "javaInterfacesMethodsTotal", "javaInterfaces");
variables.Average("javaAnnotationsElementsAvg", "javaAnnotationsElementsTotal", "javaAnnotations");
variables.Average("javaMethodParametersAvg", "javaMethodParametersTotal", "javaMethodsTotal");
variables.SetVariable("javaMethodsReturnsTotal", state.GlobalInfo.Statements[FlowStatement.Return]);
foreach (KeyValuePair <string, int> fieldType in global.FieldTypes.ListFromTop())
{
variables.AddToArray("javaFieldTypes", new { type = fieldType.Key, amount = fieldType.Value });
}
foreach (KeyValuePair <string, int> methodReturnType in global.MethodReturnTypes.ListFromTop())
{
variables.AddToArray("javaMethodReturnTypes", new { type = methodReturnType.Key, amount = methodReturnType.Value });
}
foreach (KeyValuePair <string, int> methodParameterType in global.MethodParameterTypes.ListFromTop())
{
variables.AddToArray("javaMethodParameterTypes", new { type = methodParameterType.Key, amount = methodParameterType.Value });
}
// enums
variables.Average("javaEnumsValuesAvg", "javaEnumsValuesTotal", "javaEnums");
// annotations
List <KeyValuePair <string, int> > annotationUses = global.AnnotationUses.ListFromTop();
int totalAnnotationsUsed = annotationUses.Sum(kvp => kvp.Value);
for (int annotationIndex = 0; annotationIndex < Math.Min(annotationUses.Count, 10); annotationIndex++)
{
variables.AddToArray("javaAnnotationsUsedTop", new { name = annotationUses[annotationIndex].Key, amount = annotationUses[annotationIndex].Value });
}
variables.SetVariable("javaAnnotationsUsedTotal", totalAnnotationsUsed);
variables.SetVariable("javaAnnotationsUsedOther", totalAnnotationsUsed - variables.GetVariable("javaAnnotationsUsedClasses", 0) - variables.GetVariable("javaAnnotationsUsedFields", 0) - variables.GetVariable("javaAnnotationsUsedMethods", 0));
// control flow
variables.SetVariable("javaControlFlowIf", state.GlobalInfo.Statements[FlowStatement.If] + state.GlobalInfo.Statements[FlowStatement.Else]);
variables.SetVariable("javaControlFlowFor", state.GlobalInfo.Statements[FlowStatement.For]);
variables.SetVariable("javaControlFlowEnhFor", state.GlobalInfo.Statements[FlowStatement.EnhancedFor]);
variables.SetVariable("javaControlFlowWhile", state.GlobalInfo.Statements[FlowStatement.While]);
variables.SetVariable("javaControlFlowDoWhile", state.GlobalInfo.Statements[FlowStatement.DoWhile]);
variables.SetVariable("javaControlFlowSwitch", state.GlobalInfo.Statements[FlowStatement.Switch]);
variables.SetVariable("javaControlFlowCaseTotal", state.GlobalInfo.Statements[FlowStatement.SwitchCase]);
variables.SetVariable("javaControlFlowCaseDefaultTotal", state.GlobalInfo.Statements[FlowStatement.SwitchDefault]);
variables.SetVariable("javaControlFlowCaseMin", state.GlobalInfo.MinSwitchCases);
variables.SetVariable("javaControlFlowCaseMax", state.GlobalInfo.MaxSwitchCases);
variables.Average("javaControlFlowCaseAvg", "javaControlFlowCaseTotal", "javaControlFlowSwitch");
variables.Percent("javaControlFlowCaseDefaultPerc", "javaControlFlowCaseDefaultTotal", "javaControlFlowSwitch");
variables.SetVariable("javaControlFlowTry", state.GlobalInfo.Statements[FlowStatement.Try]);
variables.SetVariable("javaControlFlowTryCatch", state.GlobalInfo.Statements[FlowStatement.TryCatch]);
variables.SetVariable("javaControlFlowTryWithResources", state.GlobalInfo.Statements[FlowStatement.TryWithResources]);
variables.SetVariable("javaControlFlowTryCatchFinally", state.GlobalInfo.TryCatchWithFinally);
variables.SetVariable("javaControlFlowTryWithResourcesFinally", state.GlobalInfo.TryWithResourcesWithFinally);
variables.Percent("javaControlFlowTryCatchFinallyPerc", "javaControlFlowTryCatchFinally", "javaControlFlowTry");
variables.Percent("javaControlFlowTryWithResourcesFinallyPerc", "javaControlFlowTryWithResourcesFinally", "javaControlFlowTry");
variables.SetVariable("javaControlFlowCatchTotal", state.GlobalInfo.Statements[FlowStatement.Catch]);
variables.SetVariable("javaControlFlowCatchMin", state.GlobalInfo.MinCatchBlocks);
variables.SetVariable("javaControlFlowCatchMax", state.GlobalInfo.MaxCatchBlocks);
variables.Average("javaControlFlowCatchAvg", "javaControlFlowCatchTotal", "javaControlFlowTry");
}
public override void SetupProject(Variables.Root variables)
{
base.SetupProject(variables);
variables.AddStateObject(this, new JavaState());
}
public void ProcessAsync()
{
var task = new Task(() => {
var variables = new Variables.Root();
int processedEntries = 0, totalEntries = SearchData.EntryCount;
int processedWeight = 0, totalWeight = HandlerList.GetTotalWeight(SearchData);
int updateCounter = 0, updateInterval = totalEntries/400;
if (Progress != null)Progress(0, processedEntries, totalEntries);
Action checkProgress;
if (Progress != null){
checkProgress = () => {
if (++updateCounter > updateInterval && Progress != null){
updateCounter = 0;
Progress((int)Math.Floor(100F*processedWeight/totalWeight), processedEntries, totalEntries);
}
};
}
else{
checkProgress = () => {};
}
// Folders
List<IFolderHandler> folderHandlers = HandlerList.GetFolderHandlers().ToList();
int folderHandlerWeight = folderHandlers.Sum(handler => handler.Weight);
foreach(string folder in SearchData.Folders){
if (cancelToken.IsCancellationRequested){
if (CancelFinish != null)CancelFinish();
return;
}
foreach(IFolderHandler folderHandler in folderHandlers){
folderHandler.Process(folder, variables);
}
++processedEntries;
++updateCounter;
processedWeight += folderHandlerWeight;
checkProgress();
}
// Files
HashSet<IFileHandler> initializedHandlers = new HashSet<IFileHandler>();
foreach(File file in SearchData.Files){
if (cancelToken.IsCancellationRequested){
if (CancelFinish != null)CancelFinish();
return;
}
IFileHandler handler = HandlerList.GetFileHandler(file);
if (initializedHandlers.Add(handler)){
handler.SetupProject(variables);
}
handler.Process(file, variables);
++processedEntries;
++updateCounter;
processedWeight += handler.Weight;
checkProgress();
}
foreach(IFileHandler handler in initializedHandlers){
handler.FinalizeProject(variables);
}
// Finalize
if (Progress != null)Progress(100, processedEntries, totalEntries);
if (Finish != null)Finish(variables);
}, cancelToken.Token);
task.ContinueWith(originalTask => {
if (Failure != null)Failure(originalTask.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
task.Start();
}
public override void Process(File file, Variables.Root variables)
{
base.Process(file, variables);
variables.Increment("fileTypeUnknown");
}
protected abstract object GetFileObject(FileIntValue fi, Variables.Root variables);
public override void SetupProject(Variables.Root variables)
{
base.SetupProject(variables);
variables.AddFlag("assets");
variables.AddStateObject(this, new State());
}
protected override object GetFileObject(FileIntValue fi, Variables.Root variables)
{
JavaState state = variables.GetStateObject <JavaState>(this);
return(new { package = state.GetFile(fi.File).Package.Replace('.', '/') + '/', file = Path.GetFileName(fi.File.FullPath), amount = fi.Value });
}
public void Process(string folder, Variables.Root variables)
{
variables.Increment("dirStructureFolders");
}
public abstract IEnumerable <Node> GenerateTreeViewData(Variables.Root variables, File file);
