AnalysisState ChangeState(AnalysisState state, MsgType msg, string idx = null, double[] minmax = null)
{
int index = -1;
if (idx != null && !int.TryParse(idx, out index))
{
MessageBox.Show(" Loaded File is Worng Index ");
return(StateLib);
}
// Change State
switch (msg)
{
case MsgType.Add:
return(Add(state, StateLib.State [index], index));
case MsgType.Remove:
return(Pop(state, index));
case MsgType.ChangeWav:
return(ChangeWaveLen(state, minmax));
default:
return(default(AnalysisState));
}
}
void RefreshDisplay()
{
if (!IsAnalysisValid())
{
return;
}
if (m_AnalysisState == AnalysisState.Completed)
{
UpdateAssemblyNames();
UpdateAssemblySelection();
m_AnalysisState = AnalysisState.Valid;
if (m_LoadButtonAnalytic != null)
{
ProjectAuditorAnalytics.SendUIButtonEvent(ProjectAuditorAnalytics.UIButton.Load, m_LoadButtonAnalytic);
}
if (m_AnalyzeButtonAnalytic != null)
{
ProjectAuditorAnalytics.SendUIButtonEventWithAnalyzeSummary(ProjectAuditorAnalytics.UIButton.Analyze, m_AnalyzeButtonAnalytic, m_ProjectReport);
}
}
activeView.Refresh();
}
private void btnLoad_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "Csv Files (.csv)|*.csv|All Files (*.*)|*.*";
if (ofd.ShowDialog() == true)
{
var res = ResultDataFrom(ofd.FileName); // 여기부터 체크를 해야한다.
if (res.isJust) // Error Handle. Change this Flow to railroad o style
{
int i = 0;
// Not handle Error Value. Need Change Flow for Error in future
//CreateState( res.Value.ToDictionary( x => i++ ) )
ucIntensityChart.Reset();
ucReflectivityChart.Reset();
StateLib = new AnalysisState();
CreateState(res.Value.ToDictionary(x => i++))
.Map(SetStateLib)
.Map(Adaptor.ToIPSResult)
.Act(x => ucAnalysisMap.SetBtnTag(x))
.Map(x => CreateMapandBar(x, 6))
.Map(x => x.ToBitmapSource())
.Act(x => ucAnalysisMap.SetImage(x));
}
else
{
MessageBox.Show("File is not valid. please select other file");
}
}
}
public override void Analyze(AnalysisState state)
{
foreach (var statement in statements)
{
statement.Analyze(state);
}
}
public AnalyzedPackage(string id, string version, string originProject, AnalysisState state, IList <string> messages)
{
Id = id;
Version = version;
OriginProject = originProject;
State = state;
Messages = messages;
}
public AnalyzedPackage(string id, string version, string originProject, AnalysisState state, string message)
{
Id = id;
Version = version;
OriginProject = originProject;
State = state;
Messages.Add(message);
}
void Analyze()
{
m_AnalyzeButtonAnalytic = ProjectAuditorAnalytics.BeginAnalytic();
m_ShouldRefresh = true;
m_AnalysisState = AnalysisState.InProgress;
m_ProjectReport = new ProjectReport();
foreach (var view in m_AnalysisViews)
{
view.Clear();
}
var newIssues = new List <ProjectIssue>();
try
{
m_ProjectAuditor.Audit(projectIssue =>
{
newIssues.Add(projectIssue);
m_ProjectReport.AddIssue(projectIssue);
},
completed =>
{
// add batch of issues
foreach (var view in m_AnalysisViews)
{
view.AddIssues(newIssues);
}
newIssues.Clear();
if (completed)
{
m_AnalysisState = AnalysisState.Completed;
}
m_ShouldRefresh = true;
},
new ProgressBarDisplay());
}
catch (AssemblyCompilationException e)
{
m_AnalysisState = AnalysisState.NotStarted;
Debug.LogError(e);
}
}
void Analyze()
{
m_AnalyzeButtonAnalytic = ProjectAuditorAnalytics.BeginAnalytic();
m_ShouldRefresh = true;
m_AnalysisState = AnalysisState.InProgress;
m_ProjectReport = new ProjectReport();
foreach (var view in m_Views)
{
if (view != null)
{
view.Clear();
}
}
AnalysisView.SetReport(m_ProjectReport);
var newIssues = new List <ProjectIssue>();
m_ProjectAuditor.Audit(projectIssue =>
{
newIssues.Add(projectIssue);
m_ProjectReport.AddIssue(projectIssue);
},
completed =>
{
// add batch of issues
foreach (var view in m_Views)
{
if (view != null)
{
view.AddIssues(newIssues);
}
}
newIssues.Clear();
if (completed)
{
m_AnalysisState = AnalysisState.Completed;
}
m_ShouldRefresh = true;
},
new ProgressBarDisplay()
);
}
private void RefreshDisplay()
{
if (!IsAnalysisValid())
{
return;
}
if (m_AnalysisState == AnalysisState.Completed)
{
// update list of assembly names
var scriptIssues = m_ProjectReport.GetIssues(IssueCategory.ApiCalls);
m_AssemblyNames = scriptIssues.Select(i => i.assembly).Distinct().OrderBy(str => str).ToArray();
UpdateAssemblySelection();
m_AnalysisState = AnalysisState.Valid;
}
m_ActiveIssueTable.Reload();
}
void SyncStateToUi(AnalysisState state)
{
// Update the top row
string text = null;
switch (state)
{
case AnalysisState.Running:
text = "Running...";
break;
case AnalysisState.Cancelled:
text = string.Format("Found issues: {0} (Cancelled)", rootGroup.IssueCount);
break;
case AnalysisState.Error:
text = string.Format("Found issues: {0} (Failed)", rootGroup.IssueCount);
break;
case AnalysisState.Completed:
text = string.Format("Found issues: {0}", rootGroup.IssueCount);
break;
}
if (text != null)
{
var topRow = store.GetFirstNode();
// Weird way to check if the store was empty during the call above.
// Might not be portable...
if (topRow.CurrentPosition == null)
{
topRow = store.AddNode();
}
topRow.SetValue(textField, text);
}
// Set button sensitivity
bool running = state == AnalysisState.Running;
runButton.Sensitive = !running;
cancelButton.Sensitive = running;
}
void Load()
{
var path = EditorUtility.OpenFilePanel("Load from json file", m_SaveLoadDirectory, "json");
if (path.Length != 0)
{
m_LoadButtonAnalytic = ProjectAuditorAnalytics.BeginAnalytic();
m_ProjectReport = ProjectReport.Load(path);
m_AnalysisState = AnalysisState.Valid;
m_SaveLoadDirectory = Path.GetDirectoryName(path);
}
OnEnable();
UpdateAssemblyNames();
UpdateAssemblySelection();
// switch to summary view after loading
SelectView(IssueCategory.MetaData);
}
private void RefreshDisplay()
{
if (!IsAnalysisValid())
{
return;
}
if (m_AnalysisState == AnalysisState.Completed)
{
// update list of assembly names
var scriptIssues = m_ProjectReport.GetIssues(IssueCategory.ApiCalls);
m_AssemblyNames = scriptIssues.Select(i => i.assembly).Distinct().OrderBy(str => str).ToArray();
UpdateAssemblySelection();
m_AnalysisState = AnalysisState.Valid;
ProjectAuditorAnalytics.SendUIButtonEventWithAnalyzeSummary(ProjectAuditorAnalytics.UIButton.Analyze, m_AnalyzeButtonAnalytic, m_ProjectReport);
}
m_ActiveIssueTable.Reload();
}
private void actualizeState()
{
if (currentAnalyser.State != lastState)
{
lastState = currentAnalyser.State;
switch (currentAnalyser.State)
{
case AnalysisState.Initialising:
phaseText.Content = "Initialising";
break;
case AnalysisState.ForwardAnalysis:
phaseText.Content = "First phase";
break;
case AnalysisState.NextPhaseAnalysis:
phaseText.Content = "Second phase";
break;
}
}
}
void RefreshDisplay()
{
if (!IsAnalysisValid())
{
return;
}
if (m_AnalysisState == AnalysisState.Completed)
{
// update list of assembly names
var scriptIssues = m_ProjectReport.GetIssues(IssueCategory.Code);
m_AssemblyNames = scriptIssues.Select(i => i.GetCustomProperty((int)CustomProperty.Assembly)).Distinct().OrderBy(str => str).ToArray();
UpdateAssemblySelection();
m_AnalysisState = AnalysisState.Valid;
ProjectAuditorAnalytics.SendUIButtonEventWithAnalyzeSummary(ProjectAuditorAnalytics.UIButton.Analyze,
m_AnalyzeButtonAnalytic, m_ProjectReport);
}
activeAnalysisView.Refresh();
}
public static IPSResult ToIPSResult(
this AnalysisState self)
{
List <SpotData> spotlist;
var temp = self.State[0].WaveLegth.ToList();
List <double> WaveLen = self.State[0].WaveLegth.Select(x => (double)x).ToList();
spotlist = self.State.Select(x =>
new SpotData
(x.Value.Position.Pos.Value.ToPolar() as PlrCrd,
x.Value.DThickness,
x.Value.DIntenList.ToArray(),
x.Value.DReflectivity.ToArray())).ToList();
var res = new IPSResult(WaveLen)
{
SpotDataList = spotlist
};
return(res);
}
public Win_ResultAnalysis(BitmapSource img, Maybe <IPSResult> result)
{
InitializeComponent();
StateLib = new AnalysisState();
Loaded += delegate
{
var defualtImg = new Image <Gray, byte>(100, 100, new Gray(100));
ucAnalysisMap.evtClickedIndex += InOutUpdate; // Update Event
result.Match(
() => Just(defualtImg.ToBitmapSource())
.ForEach(ucAnalysisMap.SetImage),
res =>
Just(res)
.Lift(SetStateLib)
.ForEach(ucAnalysisMap.SetBtnTag)
.Lift(x => CreateMapImg(img)(res))
.ForEach(ucAnalysisMap.SetImage));
};
ucIntensityChart.SetExtractor(ExtractInten);
ucReflectivityChart.SetExtractor(ExtractRflct);
ucIntensityChart.lblTitle.Content = "Intensity";
ucIntensityChart.axisY.Title = "Intensity";
ucIntensityChart.Ysprtor.Step = 5000;
ucIntensityChart.axisY.MaxValue = 61000;
ucIntensityChart.axisY.MinValue = 0;
ucReflectivityChart.lblTitle.Content = "Reflectivity";
ucReflectivityChart.axisY.Title = "Reflectivity";
ucReflectivityChart.Ysprtor.Step = 10;
ucReflectivityChart.axisY.MaxValue = 110;
ucReflectivityChart.axisY.MinValue = 0;
}
public void UpdateSeries(AnalysisState state)
{
if (LibDatas == null)
{
LibDatas = Extractor(state).ToArray();
}
if (Labels == null)
{
Labels = ExtractLabel(state).ToArray();
}
if (state.WaveMinMax != null)
{
axisX.MinValue = state.WaveMinMax [0];
axisX.MaxValue = state.WaveMinMax [1];
}
var target = state.TargetIdx;
if (state.IsAdd)
{
var chartDatas = new ChartValues <double[]>();
var fixeddata = ClearNoise(LibDatas[target].ToArray());
chartDatas.AddRange(Range(0, fixeddata.Length)
.Where((_, i) => i % 15 == 0)
.Select(i => new double [2] {
Labels [i], fixeddata [i]
})
.ToArray());
SeriesColl[target] = CreateSeries(chartDatas, target);
}
else
{
PopSeries(target);
}
}
public void StartAnalysis(WorkspaceItem solution)
{
lock (_lock) {
tokenSource = new CancellationTokenSource();
ThreadPool.QueueUserWorkItem(delegate {
State = AnalysisState.Running;
using (var monitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor("Analyzing solution", null, false)) {
int work = 0;
foreach (var project in solution.GetAllProjects())
{
work += project.Files.Count(f => f.BuildAction == BuildAction.Compile);
}
monitor.BeginTask("Analyzing solution", work);
var processedFiles = new ConcurrentDictionary <string, object> ();
foreach (var project in solution.GetAllProjects())
{
if (tokenSource.IsCancellationRequested)
{
break;
}
var content = TypeSystemService.GetProjectContext(project);
Parallel.ForEach(project.Files, file => {
var me = new object();
var owner = processedFiles.AddOrUpdate(file.Name, me, (key, old) => old);
if (me != owner)
{
return;
}
if (file.BuildAction != BuildAction.Compile || tokenSource.IsCancellationRequested)
{
return;
}
var editor = TextFileProvider.Instance.GetReadOnlyTextEditorData(file.FilePath);
var document = TypeSystemService.ParseFile(project, editor);
if (document == null)
{
return;
}
var compilation = content.AddOrUpdateFiles(document.ParsedFile).CreateCompilation();
var resolver = new CSharpAstResolver(compilation, document.GetAst <SyntaxTree> (), document.ParsedFile as ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile);
var context = document.CreateRefactoringContextWithEditor(editor, resolver, tokenSource.Token);
CodeIssueProvider[] codeIssueProvider = RefactoringService.GetInspectors(editor.MimeType).ToArray();
Parallel.ForEach(codeIssueProvider, (provider) => {
var severity = provider.GetSeverity();
if (severity == Severity.None || tokenSource.IsCancellationRequested)
{
return;
}
try {
foreach (var issue in provider.GetIssues(context, tokenSource.Token))
{
AddIssue(file, provider, issue);
}
} catch (OperationCanceledException) {
// The operation was cancelled, no-op as the user-visible parts are
// handled elsewhere
} catch (Exception ex) {
LoggingService.LogError("Error while running code issue on:" + editor.FileName, ex);
}
});
//lastMime = editor.MimeType;
monitor.Step(1);
});
}
// Cleanup
AnalysisState oldState;
AnalysisState newState;
lock (_lock) {
oldState = state;
if (tokenSource.IsCancellationRequested)
{
newState = AnalysisState.Cancelled;
}
else
{
newState = AnalysisState.Completed;
}
state = newState;
tokenSource = null;
}
OnAnalysisStateChanged(new AnalysisStateChangeEventArgs(oldState, newState));
monitor.EndTask();
}
});
}
}
IPSResult SetStateLib(IPSResult result)
{
StateLib = result.ToState();
return(result);
}
AnalysisState SetStateLib(AnalysisState state) => StateLib = state;
/// <summary>
/// Created returns a new package with the added state and message.
/// </summary>
public AnalyzedPackage With(AnalysisState state, string message)
{
return(new AnalyzedPackage(Id, Version, OriginProject, state, message));
}
public void StartAnalysis(WorkspaceItem solution)
{
lock (_lock) {
tokenSource = new CancellationTokenSource();
processedFiles = new ConcurrentDictionary <string, object> ();
ThreadPool.QueueUserWorkItem(delegate {
State = AnalysisState.Running;
using (var monitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor("Analyzing solution", null, false)) {
AnalysisState oldState;
AnalysisState newState;
try {
int work = 0;
foreach (var project in solution.GetAllProjects())
{
work += project.Files.Count(f => f.BuildAction == BuildAction.Compile);
}
monitor.BeginTask("Analyzing solution", work);
foreach (var project in solution.GetAllProjects())
{
if (tokenSource.IsCancellationRequested)
{
break;
}
var content = TypeSystemService.GetProjectContext(project);
Parallel.ForEach(project.Files, file => {
try {
AnalyzeFile(file, content);
monitor.Step(1);
} catch (Exception ex) {
LoggingService.LogError("Error while running code issue on:" + file.Name, ex);
}
});
}
// Cleanup
lock (_lock) {
oldState = state;
if (tokenSource.IsCancellationRequested)
{
newState = AnalysisState.Cancelled;
}
else
{
newState = AnalysisState.Completed;
}
state = newState;
tokenSource = null;
}
OnAnalysisStateChanged(new AnalysisStateChangeEventArgs(oldState, newState));
} catch (Exception e) {
lock (_lock) {
oldState = state;
state = AnalysisState.Error;
newState = state;
tokenSource = null;
}
OnAnalysisStateChanged(new AnalysisStateChangeEventArgs(oldState, newState));
// Do not rethrow in a thread pool
MessageService.ShowException(e);
}
}
});
}
}
void SyncStateToUi (AnalysisState state)
{
// Update the top row
string text = null;
switch (state) {
case AnalysisState.Running:
text = "Running...";
break;
case AnalysisState.Cancelled:
text = string.Format ("Found issues: {0} (Cancelled)", rootGroup.IssueCount);
break;
case AnalysisState.Error:
text = string.Format ("Found issues: {0} (Failed)", rootGroup.IssueCount);
break;
case AnalysisState.Completed:
text = string.Format ("Found issues: {0}", rootGroup.IssueCount);
break;
}
if (text != null) {
var topRow = store.GetFirstNode ();
// Weird way to check if the store was empty during the call above.
// Might not be portable...
if (topRow.CurrentPosition == null) {
topRow = store.AddNode ();
}
topRow.SetValue (textField, text);
}
// Set button sensitivity
bool running = state == AnalysisState.Running;
runButton.Sensitive = !running;
cancelButton.Sensitive = running;
}
public AnalysisStateChangeEventArgs(AnalysisState oldState, AnalysisState newState)
{
OldState = oldState;
NewState = newState;
}
public void StartAnalysis (WorkspaceItem solution)
{
lock (_lock) {
tokenSource = new CancellationTokenSource ();
ThreadPool.QueueUserWorkItem (delegate {
State = AnalysisState.Running;
using (var monitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor ("Analyzing solution", null, false)) {
int work = 0;
foreach (var project in solution.GetAllProjects ()) {
work += project.Files.Count (f => f.BuildAction == BuildAction.Compile);
}
monitor.BeginTask ("Analyzing solution", work);
var processedFiles = new ConcurrentDictionary<string, object> ();
foreach (var project in solution.GetAllProjects ()) {
if (tokenSource.IsCancellationRequested)
break;
var content = TypeSystemService.GetProjectContext (project);
Parallel.ForEach (project.Files, file => {
var me = new object();
var owner = processedFiles.AddOrUpdate(file.Name, me, (key, old) => old);
if (me != owner)
return;
if (file.BuildAction != BuildAction.Compile || tokenSource.IsCancellationRequested)
return;
var editor = TextFileProvider.Instance.GetReadOnlyTextEditorData (file.FilePath);
var document = TypeSystemService.ParseFile (project, editor);
if (document == null)
return;
var compilation = content.AddOrUpdateFiles (document.ParsedFile).CreateCompilation ();
var resolver = new CSharpAstResolver (compilation, document.GetAst<SyntaxTree> (), document.ParsedFile as ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile);
var context = document.CreateRefactoringContextWithEditor (editor, resolver, tokenSource.Token);
CodeIssueProvider[] codeIssueProvider = RefactoringService.GetInspectors (editor.MimeType).ToArray ();
Parallel.ForEach (codeIssueProvider, (provider) => {
var severity = provider.GetSeverity ();
if (severity == Severity.None || tokenSource.IsCancellationRequested)
return;
try {
foreach (var issue in provider.GetIssues (context, tokenSource.Token)) {
AddIssue (file, provider, issue);
}
} catch (OperationCanceledException) {
// The operation was cancelled, no-op as the user-visible parts are
// handled elsewhere
} catch (Exception ex) {
LoggingService.LogError ("Error while running code issue on:" + editor.FileName, ex);
}
});
//lastMime = editor.MimeType;
monitor.Step (1);
});
}
// Cleanup
AnalysisState oldState;
AnalysisState newState;
lock (_lock) {
oldState = state;
if (tokenSource.IsCancellationRequested) {
newState = AnalysisState.Cancelled;
} else {
newState = AnalysisState.Completed;
}
state = newState;
tokenSource = null;
}
OnAnalysisStateChanged(new AnalysisStateChangeEventArgs(oldState, newState));
monitor.EndTask ();
}
});
}
}
public abstract void Analyze(AnalysisState state);
public AnalysisResult(AnalysisManifest manifest, AnalysisState state, int stateInfo)
{
this.manifest = manifest;
this.state = state;
this.stateInfo = stateInfo;
}
public void StartAnalysis (WorkspaceItem solution)
{
lock (_lock) {
tokenSource = new CancellationTokenSource ();
processedFiles = new ConcurrentDictionary<string, object> ();
ThreadPool.QueueUserWorkItem (delegate {
State = AnalysisState.Running;
using (var monitor = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor ("Analyzing solution", null, false)) {
AnalysisState oldState;
AnalysisState newState;
try {
int work = 0;
foreach (var project in solution.GetAllProjects ()) {
work += project.Files.Count (f => f.BuildAction == BuildAction.Compile);
}
monitor.BeginTask ("Analyzing solution", work);
foreach (var project in solution.GetAllProjects ()) {
if (tokenSource.IsCancellationRequested)
break;
var content = TypeSystemService.GetProjectContext (project);
Parallel.ForEach (project.Files, file => {
try {
AnalyzeFile (file, content);
monitor.Step (1);
} catch (Exception ex) {
LoggingService.LogError ("Error while running code issue on:" + file.Name, ex);
}
});
}
// Cleanup
lock (_lock) {
oldState = state;
if (tokenSource.IsCancellationRequested) {
newState = AnalysisState.Cancelled;
} else {
newState = AnalysisState.Completed;
}
state = newState;
tokenSource = null;
}
OnAnalysisStateChanged (new AnalysisStateChangeEventArgs (oldState, newState));
} catch (Exception e) {
lock (_lock) {
oldState = state;
state = AnalysisState.Error;
newState = state;
tokenSource = null;
}
OnAnalysisStateChanged (new AnalysisStateChangeEventArgs (oldState, newState));
// Do not rethrow in a thread pool
MessageService.ShowException (e);
}
}
});
}
}
public AnalysisStateChangeEventArgs (AnalysisState oldState, AnalysisState newState)
{
OldState = oldState;
NewState = newState;
}
void SendState(AnalysisState state) // side func => state.Act(x => ucIntensityChart.UpdateSeries(x)) .Act(x => ucReflectivityChart.UpdateSeries(x));
public override void Analyze(AnalysisState state)
{
}
void OnEnable()
{
var currentState = m_AnalysisState;
m_AnalysisState = AnalysisState.Initializing;
ProjectAuditorAnalytics.EnableAnalytics();
m_ProjectAuditor = new ProjectAuditor();
UpdateAreaSelection();
UpdateAssemblySelection();
if (m_TextFilter == null)
{
m_TextFilter = new TextFilter();
}
var viewDescriptors = ViewDescriptor.GetAll();
Array.Sort(viewDescriptors, (a, b) => a.menuOrder.CompareTo(b.menuOrder));
m_ViewDropdownItems = new Utility.DropdownItem[viewDescriptors.Length];
m_Views = new AnalysisView[viewDescriptors.Length];
for (int i = 0; i < viewDescriptors.Length; i++)
{
var desc = viewDescriptors[i];
var layout = m_ProjectAuditor.GetLayout(desc.category);
var isSupported = layout != null;
m_ViewDropdownItems[i] = new Utility.DropdownItem
{
Content = new GUIContent(string.IsNullOrEmpty(desc.menuLabel) ? desc.name : desc.menuLabel),
SelectionContent = new GUIContent("View: " + desc.name),
Enabled = isSupported
};
if (!isSupported)
{
Debug.Log("Project Auditor module " + desc.category + " is not supported.");
continue;
}
var view = desc.viewType != null ? (AnalysisView)Activator.CreateInstance(desc.viewType) : new AnalysisView();
view.Create(desc, layout, m_ProjectAuditor.config, m_Preferences, this);
if (currentState == AnalysisState.Valid)
{
view.AddIssues(m_ProjectReport.GetIssues(desc.category));
}
m_Views[i] = view;
}
if (currentState != AnalysisState.Valid)
{
m_ProjectReport = new ProjectReport();
}
AnalysisView.SetReport(m_ProjectReport);
AnalysisView.OnChangeView = SelectView;
GetView <ShaderVariantsView>().SetShadersAuditor(m_ProjectAuditor.GetAuditor <ShadersAuditor>());
// are we reloading from a valid state?
if (currentState == AnalysisState.Valid && m_ActiveViewIndex < viewDescriptors.Length)
{
m_AnalysisState = currentState;
}
else
{
m_AnalysisState = AnalysisState.Initialized;
}
RefreshDisplay();
Instance = this;
}
Maybe <AnalysisState> RefreshState(AnalysisState newstate)
{
StateLib = newstate;
return(StateLib);
}
public LicensedPackage(string packageId, string version, string originProject, string license, AnalysisState state, IList <string> messages)
: base(packageId, version, originProject, state, messages)
{
License = license;
}
