public Session(IReceiver receiver, IAnalysis analysis)
{
Id = Guid.NewGuid();
Receiver = receiver;
DiagnoseOutputEntries = new ReactiveCollection<IDiagnoseOutputEntry>();
Analysis = new ReactiveCollection<IAnalysis>();
Analysis.ItemsAdded.Subscribe(x =>
{
foreach (var diagnoseOutputEntry in DiagnoseOutputEntries)
{
x.ProcessNewDiagnoseOutputEntry(diagnoseOutputEntry);
}
});
Analysis.Add(analysis);
DiagnoseOutputEntries.ItemsAdded.Subscribe(x =>
{
foreach (var analyse in Analysis)
{
analyse.ProcessNewDiagnoseOutputEntry(x);
}
});
}
/// <summary>
/// Create a new one.
/// </summary>
/// <param name="cache"></param>
/// <param name="ss"></param>
/// <param name="choices"></param>
/// <param name="analysis"></param>
/// <param name="mediator"></param>
public TryAWordSandbox(FdoCache cache, Mediator mediator, IVwStylesheet ss, InterlinLineChoices choices,
IAnalysis analysis)
: base(cache, mediator, ss, choices)
{
SizeToContent = true;
LoadForWordBundleAnalysis(analysis.Hvo);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Constructor for ParaFragment
/// </summary>
/// <param name="seg">The segment.</param>
/// <param name="ichBegin">The character offset to the start of the fragment, relative
/// to the start of the paragraph.</param>
/// <param name="ichEnd">The character offset to the end (actually the limit) of the
/// fragment, relative to the start of the paragraph.</param>
/// <param name="analyis">The analyis.</param>
/// ------------------------------------------------------------------------------------
public ParaFragment(ISegment seg, int ichBegin, int ichEnd, IAnalysis analyis)
{
Segment = seg;
BeginOffset = ichBegin;
EndOffset = ichEnd;
Analysis = analyis;
}
/// <summary>
/// Create a new one.
/// </summary>
/// <param name="cache"></param>
/// <param name="ss"></param>
/// <param name="choices"></param>
/// <param name="analysis"></param>
/// <param name="mediator"></param>
public TryAWordSandbox(FdoCache cache, Mediator mediator, IVwStylesheet ss, InterlinLineChoices choices,
IAnalysis analysis)
: base(cache, mediator, ss, choices)
{
SizeToContent = true;
LoadForWordBundleAnalysis(analysis.Hvo);
}
private void Analysis()
{
_state = true;
SetControlEnable(ButtonAnalysis, false);
if (!String.IsNullOrEmpty(textBoxUrl.Text.TrimStart().TrimEnd()))
{
IAnalysis analysis = ArticleAnalysisFactory.Instance().CreateAnalysis(1);
if (analysis != null)
{
ArticleDownAction downAction = new ArticleDownAction();
String html = downAction.GetHtml(textBoxUrl.Text.TrimStart().TrimEnd());
ArticleModel article = analysis.Analysis(html);
String articleJson = Newtonsoft.Json.JsonConvert.SerializeObject(article);
AddMessage(articleJson);
}
else
{
AddMessage("暂时还未支持该站点的文章采集，程序猿正在紧张处理中！！！");
}
}
else
{
AddMessage("请输入需要采集的文章地址！");
}
_state = false;
SetControlEnable(ButtonAnalysis, true);
}
public AnalysisViewModel(IDispatcher dispatcher,
AnalysisViewTemplate viewTemplate,
IAnalysis analyser,
IAnalysisStorage analysisStorage,
IPluginLoader pluginLoader)
{
_dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
_analyser = analyser ?? throw new ArgumentNullException(nameof(analyser));
_analysisStorage = analysisStorage ?? throw new ArgumentNullException(nameof(analysisStorage));
_viewTemplate = viewTemplate ?? throw new ArgumentNullException(nameof(viewTemplate));
_pluginLoader = pluginLoader ?? throw new ArgumentNullException(nameof(pluginLoader));
_pages = new ObservableCollection <AnalysisPageViewModel>();
_addPageCommand = new DelegateCommand(AddNewPage);
_removeCommand = new DelegateCommand(RemoveThis);
_captureSnapshotCommand = new DelegateCommand2(CaptureSnapshot)
{
CanBeExecuted = true
};
if (viewTemplate.Pages.Any())
{
foreach (var pageTemplate in viewTemplate.Pages)
{
// TODO: Solve this conundrum!
AddPage((PageTemplate)pageTemplate);
}
}
else
{
AddNewPage();
}
_selectedPage = _pages.FirstOrDefault();
}
private void SimpleAnalysis()
{
_state = true;
SetControlEnable(buttonSimpleAnalysis, false);
if (!String.IsNullOrEmpty(textBoxUrl.Text.TrimStart().TrimEnd()))
{
IAnalysis analysis = ArticleAnalysisFactory.Instance().CreateAnalysis(1);
if (analysis != null)
{
ArticleDownAction downAction = new ArticleDownAction();
String html = downAction.GetHtml(textBoxUrl.Text.TrimStart().TrimEnd());
_simpleArticleModel = analysis.SimpleAnalysis(html);
String articleJson = Newtonsoft.Json.JsonConvert.SerializeObject(_simpleArticleModel);
StringBuilder builder = new StringBuilder();
builder.AppendFormat("<html><body>{0}</body></html>", _simpleArticleModel.ContentModels);
_filePath = String.Format(@"{0}html\\htmltest_{1}.html", AppDomain.CurrentDomain.BaseDirectory, DateTime.Now.ToString("ffff"));
File.WriteAllText(_filePath, builder.ToString(), Encoding.Unicode);
//_filePath = string.Format("file:///{0}", _filePath);
AddMessage(articleJson);
}
else
{
AddMessage("暂时还未支持该站点的文章采集，程序猿正在紧张处理中！！！");
}
}
else
{
AddMessage("请输入需要采集的文章地址！");
}
_state = false;
SetControlEnable(buttonSimpleAnalysis, true);
}
public static ForwardAnalysisSolver <AState, Type, EdgeData> Make <Local, Parameter, Method, Field, Source, Dest, Context>(
IDecodeMSIL <APC, Local, Parameter, Method, Field, Type, Source, Dest, Context, EdgeData> decoder,
IAnalysis <APC, AState, IVisitMSIL <APC, Local, Parameter, Method, Field, Type, Source, Dest, AState, AState>, EdgeData> driver,
ILPrinter <APC> printer
)
where Context : IMethodContext <Field, Method>
{
Contract.Requires(decoder != null);
Contract.Requires(driver != null);
IVisitMSIL <APC, Local, Parameter, Method, Field, Type, Source, Dest, AState, AState> visitor = driver.Visitor();
var result = new ForwardAnalysisSolver <AState, Type, EdgeData>(
decoder.Context.MethodContext.CFG,
delegate(APC pc, AState state) { return(decoder.ForwardDecode <AState, AState, IVisitMSIL <APC, Local, Parameter, Method, Field, Type, Source, Dest, AState, AState> >(pc, visitor, state)); },
driver.EdgeConversion,
driver.Join,
driver.ImmutableVersion,
driver.MutableVersion,
driver.Dump,
delegate(APC pc, AState state) { return(decoder.IsUnreachable(pc) || driver.IsBottom(pc, state)); },
delegate(APC pc, AState state) { return(driver.IsTop(pc, state)); },
printer,
decoder.Display,
decoder.EdgeData
);
result.CachePolicy = driver.CacheStates(result);
return(result);
}
/// <inheritdoc />
public Task SaveSnapshot(IAnalysis analysis, AnalysisViewTemplate viewTemplate)
{
var tmp = analysis as ActiveAnalysis;
if (tmp == null)
{
throw new ArgumentException("It makes no sense to create a snapshot from anything else but an active analysis",
nameof(analysis));
}
var analysisSnapshot = tmp.CreateSnapshot();
var template = new AnalysisTemplate(analysisSnapshot.Analysers.Select(x => new AnalyserTemplate
{
Id = x.Id,
AnalyserPluginId = x.AnalyserPluginId,
Configuration = x.Configuration
}));
var clone = viewTemplate.Clone();
var results = analysisSnapshot.Analysers.Select(x => new AnalyserResult
{
AnalyserId = x.Id,
Result = x.Result
}).ToList();
var snapshot = new Core.Analysis.AnalysisSnapshot(template, clone, results);
return(_snapshots.Save(snapshot));
}
/// <summary>
/// add any alternative forms (in alternative writing systems) to the wordform.
/// Overwrite any existing alternative form in a given alternative writing system.
/// </summary>
/// <param name="analysis"></param>
/// <param name="word"></param>
/// <param name="wsMainVernWs"></param>
/// <param name="strFactory"></param>
private static void AddAlternativeWssToWordform(IAnalysis analysis, Word word, ILgWritingSystem wsMainVernWs, ITsStrFactory strFactory)
{
ILgWritingSystemFactory wsFact = analysis.Cache.WritingSystemFactory;
var wf = analysis.Wordform;
foreach (var wordItem in word.Items)
{
ITsString wffAlt = null;
switch (wordItem.type)
{
case "txt":
var wsAlt = GetWsEngine(wsFact, wordItem.lang);
if (wsAlt.Handle == wsMainVernWs.Handle)
{
continue;
}
wffAlt = strFactory.MakeString(wordItem.Value, wsAlt.Handle);
if (wffAlt.Length > 0)
{
wf.Form.set_String(wsAlt.Handle, wffAlt);
}
break;
}
}
}
public Session(IReceiver receiver, IAnalysis analysis)
{
Id = Guid.NewGuid();
Receiver = receiver;
DiagnoseOutputEntries = new ReactiveCollection <IDiagnoseOutputEntry>();
Analysis = new ReactiveCollection <IAnalysis>();
Analysis.ItemsAdded.Subscribe(x =>
{
foreach (var diagnoseOutputEntry in DiagnoseOutputEntries)
{
x.ProcessNewDiagnoseOutputEntry(diagnoseOutputEntry);
}
});
Analysis.Add(analysis);
DiagnoseOutputEntries.ItemsAdded.Subscribe(x =>
{
foreach (var analyse in Analysis)
{
analyse.ProcessNewDiagnoseOutputEntry(x);
}
});
}
private FDO.IText MakeText(string contents)
{
var text = Cache.ServiceLocator.GetInstance <ITextFactory>().Create();
var stText = Cache.ServiceLocator.GetInstance <IStTextFactory>().Create();
text.ContentsOA = stText;
var para = Cache.ServiceLocator.GetInstance <IStTxtParaFactory>().Create();
stText.ParagraphsOS.Add(para);
para.Contents = Cache.TsStrFactory.MakeString(contents, Cache.DefaultVernWs);
using (var pp = new ParagraphParser(Cache))
{
pp.Parse(para);
}
ISegment seg = para.SegmentsOS.First();
for (int i = 0; i < seg.AnalysesRS.Count; i++)
{
IAnalysis analysis = seg.AnalysesRS[i];
var wordform = analysis as IWfiWordform;
if (wordform != null)
{
seg.AnalysesRS[i] = wordform.AnalysesOC.First().MeaningsOC.First();
}
}
return(text);
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='job'>
/// </param>
/// <param name='workitem'>
/// </param>
/// <param name='analysisType'>
/// </param>
/// <param name='analysisName'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> GetDetailsAsync(this IAnalysis operations, string job, string workitem, string analysisType, string analysisName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
using (var _result = await operations.GetDetailsWithHttpMessagesAsync(job, workitem, analysisType, analysisName, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public static ForwardAnalysis <AbstractState, EdgeData> Make <Source, Dest, Context> (
IILDecoder <APC, Source, Dest, Context, EdgeData> decoder,
IAnalysis <APC, AbstractState, IILVisitor <APC, Source, Dest, AbstractState, AbstractState>, EdgeData> analysis)
where Context : IMethodContextProvider
{
IILVisitor <APC, Source, Dest, AbstractState, AbstractState> visitor = analysis.GetVisitor();
var forwardAnalysisSolver = new ForwardAnalysis <AbstractState, EdgeData> (
decoder.ContextProvider.MethodContext.CFG,
(pc, state) => decoder.ForwardDecode <AbstractState, AbstractState, IILVisitor <APC, Source, Dest, AbstractState, AbstractState> > (pc, visitor, state),
analysis.Join,
analysis.ImmutableVersion,
analysis.MutableVersion,
analysis.EdgeConversion,
decoder.EdgeData,
(pc, state) => {
if (!decoder.IsUnreachable(pc))
{
return(analysis.IsBottom(pc, state));
}
return(true);
},
analysis.Dump
);
analysis.SaveFixPointInfo(forwardAnalysisSolver);
return(forwardAnalysisSolver);
}
/// <summary>
/// Informs the guess service that the indicated occurrence is being replaced with the specified new
/// analysis. If necessary clear the GuessTable. If possible update it. The most common and
/// performance-critical case is confirming a guess. Return true if the cache was changed.
/// </summary>
public bool UpdatingOccurrence(IAnalysis oldAnalysis, IAnalysis newAnalysis)
{
if (m_guessTable == null)
{
return(false); // already cleared, forget it.
}
if (oldAnalysis == newAnalysis)
{
return(false); // nothing changed, no problem.
}
if (!(oldAnalysis is IWfiWordform))
{
// In general, no predicting what effect it has on the guess for the
// wordform or analysis that owns the old analysis. If the old analysis is
// not the default for its owner or owner's owner, we are OK, but that's too rare
// to worry about.
ClearGuessData();
return(true);
}
if (newAnalysis is IWfiWordform || newAnalysis.Wordform == null)
{
return(false); // unlikely but doesn't mess up our guesses.
}
var result = false;
// if the new analysis is NOT the guess for one of its owners, one more occurrence might
// make it the guess, so we need to regenerate.
IAnalysis currentDefault;
if (!m_guessTable.TryGetValue(newAnalysis.Wordform, out currentDefault))
{
// We have no guess for this wordform: the new analysis becomes it.
m_guessTable[newAnalysis.Wordform] = newAnalysis;
result = true; // we didn't clear the cache but did change it.
}
else if (currentDefault != newAnalysis)
{
// Some other analysis just became more common...maybe now the default?
ClearGuessData();
return(true);
}
if (newAnalysis is IWfiAnalysis)
{
return(result);
}
if (!m_guessTable.TryGetValue(newAnalysis.Analysis, out currentDefault))
{
// We have no guess for this analysis: the new analysis becomes it.
m_guessTable[newAnalysis.Analysis] = newAnalysis;
result = true; // we didn't clear the cache but did change it.
}
else if (currentDefault != newAnalysis)
{
// Some other analysis just became more common...maybe now the default?
ClearGuessData();
return(true);
}
// We haven't messed up any guesses so the guess table can survive.
return(result); // but we may have filled in some guesses.
}
public Guid AddSession(IReceiver receiver, IAnalysis analysis)
{
var newSession = new Session(receiver, analysis);
Sessions.Add(newSession);
return(newSession.Id);
}
private void ShowAnalysis(string analysisName)
{
AnalysisSelected?.Close();
IAnalysis analysis = _analysisViewModels[analysisName];
analysis.Initialize();
AnalysisSelected = analysis;
}
public Guid AddSession(IReceiver receiver, IAnalysis analysis)
{
var newSession = new Session(receiver, analysis);
Sessions.Add(newSession);
return newSession.Id;
}
public void SaveCommit(IAnalysis analysis, out bool success)
{
using (IUnitOfWork u = UnitOfWork.Begin())
{
Save(analysis, out success);
if (success)
u.Commit();
}
}
public Func <AnalysisState, IFixpointInfo <APC, AnalysisState> > CreateForward <AnalysisState>(
IAnalysis <APC, AnalysisState, IVisitMSIL <APC, Local, Parameter, Method, Field, Type, Expression, Variable, AnalysisState, AnalysisState>, EdgeData> analysis,
DFAOptions options)
{
var solver = ForwardAnalysisSolver <AnalysisState, Type, EdgeData> .Make(this.ildecoder, analysis, this.Printer);
solver.Options = options;
return((initialState) => { solver.Run(initialState); return solver; });
}
public bool Equals(IAnalysis other)
{
return(other != null &&
Name == other.Name &&
ClosingPrice == other.ClosingPrice &&
QtyInBuyingPacket == other.QtyInBuyingPacket &&
EqualityComparer <ITechnicalAnalysis> .Default.Equals(TechnicalAnalysis, other.TechnicalAnalysis) &&
EqualityComparer <IFinancialAnalysis> .Default.Equals(FinancialAnalysis, other.FinancialAnalysis));
}
public AnalysisContainer GetSentence()
{
if (iAnalysis == null)
{
iAnalysis = objAnalysis.GetComponent <IAnalysis>();
}
return(iAnalysis.Analysis(testChar));
}
private void CreateTryAWordSandbox()
{
// skip if it's before we've set the word
if (m_sWordForm == null)
{
return;
}
// skip if it's before we've set up the rootsite control
if (m_rootb == null)
{
return;
}
// skip if we're not visible
if (!Visible)
{
return;
}
//Debug.WriteLine("TryAWordRootSite:WordForm - creating sandbox for " + m_sWordForm.Text);
NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
m_wordform = WfiWordformServices.FindOrCreateWordform(m_cache, m_sWordForm);
});
//if (m_cache.IsDummyObject(hvo))
// m_wordform = new WfiWordform();
IAnalysis analysis = m_vc.GetGuessForWordform(m_wordform, m_cache.DefaultVernWs);
if (analysis is NullWAG)
{
analysis = m_wordform;
}
m_rootb.SetRootObject(analysis.Hvo, m_vc, m_kfragSingleInterlinearAnalysisWithLabels, m_styleSheet);
//Debug.Assert(m_tryAWordSandbox == null);
m_tryAWordSandbox = new TryAWordSandbox(m_cache,
Mediator,
m_propertyTable,
StyleSheet,
m_vc.LineChoices,
analysis);
m_tryAWordSandbox.Visible = false;
Controls.Add(m_tryAWordSandbox);
SetSandboxSize();
SetSandboxLocation();
m_tryAWordSandbox.Visible = true;
SetBackgroundColor();
int height = Math.Max(ScrollRange.Height, m_tryAWordSandbox.Height) + SystemInformation.HorizontalScrollBarHeight;
if (Height != height)
{
Height = height;
}
m_tryAWordSandbox.SizeChanged += m_tryAWordSandbox_SizeChanged;
//m_tryAWordSandbox.Focus();
}
public void DeleteCommit(IAnalysis analysis)
{
Checks.Argument.IsNotNull(analysis, "analysis");
using (IUnitOfWork u = UnitOfWork.Begin())
{
_repo.Remove(analysis);
u.Commit();
}
}
public Func <AState, IFixPointInfo <APC, AState> > CreateForward <AState> (
IAnalysis <APC, AState, IILVisitor <APC, Expression, Variable, AState, AState>, EdgeData> analysis)
{
ForwardAnalysis <AState, EdgeData> solver = ForwardAnalysis <AState, EdgeData> .Make(ILDecoder, analysis);
return((initialState) => {
solver.Run(initialState);
return solver;
});
}
public void DeleteCommit(IAnalysis analysis)
{
Checks.Argument.IsNotNull(analysis, "analysis");
using (IUnitOfWork u = UnitOfWork.Begin())
{
_repo.Remove(analysis);
u.Commit();
}
}
public void SaveCommit(IAnalysis analysis, out bool success)
{
using (IUnitOfWork u = UnitOfWork.Begin())
{
Save(analysis, out success);
if (success)
{
u.Commit();
}
}
}
private static IAnalysis[] LoadRibbonAnalyses(IInterlinRibbon mrib, int[] ribbonHvos)
{
var chvos = ribbonHvos.Length;
var result = new IAnalysis[chvos];
for (var i = 0; i < chvos; i++)
{
result[i] = ((InterlinRibbonDecorator)mrib.Decorator).OccurrenceFromHvo(ribbonHvos[i]).Analysis;
}
return(result);
}
private IAnalysis GetBestGuess(IAnalysis wag, int ws)
{
if (wag is IWfiWordform)
{
return(GetBestGuess(wag.Wordform, ws));
}
if (wag is IWfiAnalysis)
{
return(GetBestGuess(wag.Analysis));
}
return(new NullWAG());
}
private static void AddWordToSegment(ISegment newSegment, Word word, ITsStrFactory strFactory)
{
//use the items under the word to determine what kind of thing to add to the segment
var cache = newSegment.Cache;
IAnalysis analysis = CreateWordAnalysisStack(cache, word, strFactory);
// Add to segment
if (analysis != null)
{
newSegment.AnalysesRS.Add(analysis);
}
}
public IOutputType GetOutputType(IAnalysis analysis)
{
while (true)
{
_userInterface.AskWhichOutputType(analysis);
var input = _userInterface.ReadLine();
if (analysis.ValidOutputOption(input))
return analysis.GetOutputType(input);
if (input.Equals("7"))
_userInterface.EasterEgg();
_userInterface.NotifyInvalidResponse();
}
}
public bool TryGetAnalysisFor(AnalysisId id, out IAnalysis analysis)
{
lock (_syncRoot)
{
ActiveAnalysis tmp;
if (_analyses.TryGetValue(id, out tmp))
{
analysis = tmp;
return(true);
}
}
analysis = null;
return(false);
}
private DataTable GetCollectionDetails()
{
DataTable dtColl = new DataTable();
try
{
IAnalysis objCashdesk = AnalysisBusinessObject.CreateInstance();
dtColl = objCashdesk.GetWeeklyCollectionDetails(_iWeekID);
}
catch (Exception ex)
{
ExceptionManager.Publish(ex);
}
return(dtColl);
}
public virtual async Task <T> GetAnalysis <T>(string analysisIdString = "",
bool recordInDb = false)
where T : IAnalysis
{
if (typeof(T) != typeof(TAnalysis))
{
throw new Exceptions.AnalysisTypeNotRecognizedException(typeof(T));
}
IAnalysis retAnalysis = null;
retAnalysis = await GetAnalysisImpl(analysisIdString, recordInDb);
AnalysisHasBeenBuilt = true;
return((T)retAnalysis);
}
// Caller must create UOW
private void ApplyAnalysisToInstancesOfWordform(IAnalysis newAnalysis, IWfiWordform oldWordform, IWfiWordform newWordform)
{
var navigator = new SegmentServices.StTextAnnotationNavigator(SelectedOccurrence);
foreach (var occ in navigator.GetAnalysisOccurrencesAdvancingInStText().ToList())
{
// We certainly want to update any occurrence that exactly matches the wordform of the analysis we are confirming.
// If oldWordform is different, we are confirming a different case form from what occurred in the text,
// and we only confirm these if SelectedOccurrence and occ are both sentence-initial.
// We want to do that only for sentence-initial occurrences.
if (occ.Analysis == newWordform || (occ.Analysis == oldWordform && occ.Index == 0 && SelectedOccurrence.Index == 0))
{
occ.Segment.AnalysesRS[occ.Index] = newAnalysis;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="socket"></param>
/// <param name="socketPool"></param>
/// <param name="id">通道Id</param>
internal YChannel(Socket socket, SocketAsyncEventArgsPool socketPool, ChannelType ct, string id = "")
{
if (socket == null)
{
return;
}
this.ChannelType = ct;
SetKeepAliveValues(socket, true, KeepTime, KeepTime * 2);
this.socket = socket;
address = (((IPEndPoint)socket.RemoteEndPoint).Address).ToString();
port = ((IPEndPoint)socket.RemoteEndPoint).Port;
this.Id = string.IsNullOrWhiteSpace(id) ? string.Format("{0}:{1}", address, port) : id;
this.socketPool = socketPool;
dataPacketManager = new YDataPacketManager();
dataPacketManager.DataPacketReceived += dataPacketManager_DataPacketReceived;
}
public void Save(IAnalysis analysis, out bool success)
{
Checks.Argument.IsNotNull(analysis, "myShow");
success = false;
if (null == _repo.FindById(analysis.AnalysisId).SingleOrDefault())
{
try
{
_repo.Add(analysis);
success = true;
}
catch (Exception ex)
{
success = false;
}
}
}
/// <summary>
/// Make sure we have the right list of occurrences for the specified analysis (assumes we are using ExactOccurrences).
/// </summary>
public void UpdateExactAnalysisOccurrences(IAnalysis obj)
{
UpdateAnalysisOccurrences(obj, false);
}
public void AskWhichOutputType(IAnalysis analysis)
{
throw new NotImplementedException();
}
public MultipleAnalysesModel(IFullName item, IAnalysis[] analyses) {
this.analyses = analyses;
Item = item;
Text = Utils.EscapeString(DisplayNameCreator.CreateFullName(item), false);
}
/// <summary>
/// Finds an existing wfiAnalysis related to the given cba.InstanceOf.
/// If none exists, we'll create one.
/// </summary>
private IWfiAnalysis FindOrCreateWfiAnalysis(IAnalysis analysisActual)
{
IWfiAnalysis actualWfiAnalysis = analysisActual.Analysis;
if (actualWfiAnalysis == null)
actualWfiAnalysis = CreateWfiAnalysisForAnalysis(analysisActual);
return actualWfiAnalysis;
}
public void UpdatingOccurrence(IAnalysis oldAnalysis, IAnalysis newAnalysis)
{
m_vc.UpdatingOccurrence(oldAnalysis, newAnalysis);
}
/// <summary>
/// Get a guess for the given word or analysis.
/// </summary>
/// <param name="analysis"></param>
/// <returns></returns>
internal int GetGuess(IAnalysis analysis)
{
if (Decorator.get_IsPropInCache(analysis.Hvo, InterlinViewDataCache.AnalysisMostApprovedFlid,
(int)CellarPropertyType.ReferenceAtomic, 0))
{
int hvoResult = Decorator.get_ObjectProp(analysis.Hvo, InterlinViewDataCache.AnalysisMostApprovedFlid);
if (hvoResult != 0)
return hvoResult; // may have been cleared by setting to zero.
}
return analysis.Hvo;
}
protected IWfiMorphBundle SetMorphBundle(IAnalysis analysis, int iMorphBundle, ILexSense sense)
{
IWfiAnalysis actualWfiAnalysis = analysis.Analysis;
if (actualWfiAnalysis != null)
{
actualWfiAnalysis.MorphBundlesOS[iMorphBundle].SenseRA = sense;
return actualWfiAnalysis.MorphBundlesOS[iMorphBundle];
}
return null;
}
public void Delete(IAnalysis analysis)
{
Checks.Argument.IsNotNull(analysis, "analysis");
_repo.Remove(analysis);
}
public PluginBase()
{
Analyzer = new MsWebBrowserAnalysis();
}
private void CompareAnalyses(object expectedNode, IAnalysis actualAnalysis, string context)
{
var node = expectedNode as XmlNode;
int hvoAnalysisExpected = ParagraphBuilder.GetAnalysisId(node);
if (hvoAnalysisExpected == -1)
{
// default: no special analysis set, should have made a wordform or punctform with the same form as the node.
IAnalysis analysis = (IAnalysis)m_cache.ServiceLocator.GetObject(actualAnalysis.Hvo);
string expectedText = node.SelectSingleNode("StringValue37").InnerText;
Assert.AreEqual(expectedText, analysis.GetForm(TsStringUtils.GetWsAtOffset(m_para.Contents, 0)).Text, context);
string guid = ParagraphBuilder.GetAnnotationTypeGuid(node);
if (guid == ParagraphBuilder.WficGuid)
Assert.IsTrue(analysis is IWfiWordform, "default parse should produce wordform here " + context);
else
Assert.IsTrue(analysis is IPunctuationForm, "default parse should produce punctuation form here " + context);
}
else
{
Assert.AreEqual(hvoAnalysisExpected, actualAnalysis.Hvo, context);
}
}
private void MakeFirstSegReferenceAnalysis(IText text, IAnalysis analysis)
{
var seg = ((IStTxtPara) text.ContentsOA.ParagraphsOS[0]).SegmentsOS[0];
seg.AnalysesRS.Add(analysis);
}
private void GetRealWordformInfo(IAnalysis actualAnalysis, out int hvoActualInstanceOf, out IWfiWordform realWordform)
{
hvoActualInstanceOf = actualAnalysis.Hvo;
realWordform = actualAnalysis.Wordform;
}
/// <summary>
/// Set the analysis at the specified segment, index.
/// Enhance JohnT: may need it to fill in prior segments and/or annotations.
/// </summary>
private void SetAnalysis(int iSegment, int iSegForm, IAnalysis newGloss)
{
m_para.SegmentsOS[iSegment].AnalysesRS.Replace(iSegForm, 1, new ICmObject[] {newGloss});
}
private bool HasTrivialAnalysis(IAnalysis analysis)
{
return (!(analysis is IWfiAnalysis) && !(analysis is IWfiGloss));
}
private IWfiAnalysis CreateWfiAnalysisForAnalysis(IAnalysis actualAnalysis)
{
int hvoActualInstanceOf;
IWfiWordform actualWordform;
GetRealWordformInfo(actualAnalysis, out hvoActualInstanceOf, out actualWordform);
// Create a new WfiAnalysis for the wordform.
IWfiAnalysis actualWfiAnalysis = m_cache.ServiceLocator.GetInstance<IWfiAnalysisFactory>().Create();
actualWordform.AnalysesOC.Add(actualWfiAnalysis);
return actualWfiAnalysis;
}
public bool UpdatingOccurrence(IAnalysis oldAnalysis, IAnalysis newAnalysis)
{
if (m_loader != null)
{
CheckDisposed();
return m_loader.UpdatingOccurrence(oldAnalysis, newAnalysis);
}
return false;
}
/// <summary>
/// This awkwardly named method fits into a pattern of names for validating the outer (XML attributes) and inner
/// (XML content) parts of an XML representation of an expected value. In this case, for an IAnalysis, the only
/// thing we can verify is that it is the right object.
/// </summary>
protected override void ValidateSegFormOuterElements(object expectedSegForm, IAnalysis actualSegForm, string segFormContext)
{
CompareAnalyses(expectedSegForm, actualSegForm, segFormContext);
}
private void DisplayWord(InterlinLineSpec spec, int choiceIndex, IAnalysis wag)
{
var wsActual = m_this.GetRealWsOrBestWsForContext(m_hvoWordform, spec);
var tssRealForm = GetRealForm(wsActual, choiceIndex);
if (tssRealForm != null && tssRealForm.Length > 0)
{
m_this.IsDoingRealWordForm = true;
// LT-12203 Text chart doesn't want multiple analyses highlighting
if (m_fshowMultipleAnalyses)
{
//identify those words the user has yet to approve which have multiple possible
//guesses user or machine, and set the background to a special color
var word = wag as IWfiWordform;
if (word != null)
{
//test if there are multiple analyses that a user might choose from
if (SandboxBase.GetHasMultipleRelevantAnalyses(word))
{
m_this.SetGuessing(m_vwenv, MultipleApprovedGuessColor); //There are multiple options, set the color
}
}
}
m_vwenv.AddString(tssRealForm);
m_this.IsDoingRealWordForm = false;
return;
}
switch (m_defaultObj.ClassID)
{
case WfiWordformTags.kClassId:
case WfiAnalysisTags.kClassId:
case WfiGlossTags.kClassId:
m_vwenv.AddObj(m_hvoWordform, m_this, kfragLineChoices + choiceIndex);
break;
default:
throw new Exception("Invalid type found in Segment analysis");
}
}
/// <summary>
/// Replacing a single occurrence, we MIGHT need to reset the guess cache.
/// </summary>
public bool UpdatingOccurrence(IAnalysis oldAnalysis, IAnalysis newAnalysis)
{
var result = GuessServices.UpdatingOccurrence(oldAnalysis, newAnalysis);
if (result)
m_sdaDecorator.ClearPropFromCache(InterlinViewDataCache.AnalysisMostApprovedFlid);
return result;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Constructor for ParaFragment
/// </summary>
/// <param name="seg">The segment.</param>
/// <param name="ichBegin">The character offset to the start of the fragment, relative
/// to the start of the paragraph.</param>
/// <param name="ichEnd">The character offset to the end (actually the limit) of the
/// fragment, relative to the start of the paragraph.</param>
/// <param name="analyis">The analyis.</param>
/// ------------------------------------------------------------------------------------
public ParaFragment(ISegment seg, int ichBegin, int ichEnd, IAnalysis analyis)
{
Segment = seg;
BeginOffset = ichBegin;
EndOffset = ichEnd;
Analysis = analyis;
}
bool TryReuseAnalysis(ITsString tssTxtWord, int ichMin, int ichLim, int ianalysis, out IWfiWordform wf, out ITsString tssWordAnn, out IAnalysis analysis)
{
analysis = null;
tssWordAnn = tssTxtWord;
wf = null; // default
if (m_preExistingAnalyses.Count == 0)
{
// Enhance: This is a new paragraph that may have resulted in breaking
// up a previously existing paragraph. In that case we'd probably want to
// try to preserve the annotations/analyses.
return false;
}
// First, see if we have cached annotation ids for the wordform in this paragraph.
// the wordform and its lowercase form may already be in the cache.
string key = m_paragraphTextScanner.ToLower(tssTxtWord);
IList<int> possibleIndices;
if (!m_wordformAnnotationPossibilities.TryGetValue(key, out possibleIndices) || possibleIndices.Count == 0)
return false; // we don't have any remaining annotations matching this wordform.
possibleIndices = m_wordformAnnotationPossibilities[key];
int iAnnClosest;
GetBestPossibleAnnotation(ianalysis, possibleIndices, ichMin, ichLim - ichMin, out iAnnClosest);
if (iAnnClosest == -1)
return false; // can happen, if all the possible reuseable ones are actually phrases.
bool fUsedBestPossible = false;
try
{
wf = m_preExistingAnalyses[iAnnClosest].Wordform;
int wsTxtWord = TsStringUtils.GetWsAtOffset(tssTxtWord, 0);
tssWordAnn = wf.Form.get_String(wsTxtWord);
// Did we find it at the exact expected place in the sequence?
if (ianalysis != iAnnClosest)
{
// No, we didn't. Apply various heuristics to see whether we should use it.
// Enhance: If the character offsets in this text paragraph overlap
// the user probably deleted a paragraph break.
// in that case we could be smarter about looking for matches at the end of the paragraph
// rather than at the beginning.
// Verify the closest is within reasonable bounds.
if (Math.Abs(ianalysis - iAnnClosest) > 100)
{
// someone may have significantly altered the text,
// or it belongs to a wordform later in the text.
// Either case, safe not to guess a match.
tssWordAnn = tssTxtWord;
return false;
}
if (tssWordAnn.Length == 0)
{
// There are certain cases (e.g. during import) where
// the paragraph text will not have a default vernacular writing system for the current
// wordform. So, instead of trying to find the best vernacular form (again), we'll
// just assume that it matches some form of the tssWordTxt in this context.
tssWordAnn = tssTxtWord;
}
// JohnT: don't see any equivalent for this optimization, we don't know where in the
// text the closest occurrence used to be.
//// see if we can match on the target offset, so we don't have to search more through the text.
//if (m_paragraphTextScanner.MatchesWordInText(tssWordAnn, ichMinAnnClosest))
//{
// tssWordAnn = tssTxtWord;
// return false;
//}
// Otherwise, verify there isn't another place in the text closer to the
// offsets for the annotation's wordform.
if (ianalysis < iAnnClosest)
{
int intermediateWordCount = m_paragraphTextScanner.NextOccurrenceOfWord(tssWordAnn, ichLim,
ichMin +
tssWordAnn.Length);
if (intermediateWordCount != -1 && intermediateWordCount < iAnnClosest - ianalysis)
{
// we found a closer possible occurrence.
tssWordAnn = tssTxtWord;
return false;
}
}
else
{
// the match is earlier in the text than expected; it will certainly be closer
// to this occurrence than any later one.
}
}
else
{
// The same wordform occurred at the same position in the old analysis of the paragraph.
int ichLimAnnClosest = m_preExistingAnalyses[iAnnClosest].GetForm(m_paraWs).Length + ichMin;
if (ichLimAnnClosest > ichLim)
{
// annotation must be for a phrase. See if it matches our text before using the id, otherwise we can crash (LT-6244).
if (!m_paragraphTextScanner.MatchesWordInText(tssWordAnn, ichMin))
{
// annotation didn't actually match our text, so return.
tssWordAnn = tssTxtWord;
return false;
}
}
else
{
// verify tssWordAnn is actual compatible with our spot in the text.
if (!m_paragraphTextScanner.MatchesWord(tssWordAnn, tssTxtWord))
{
// perhaps they changed the writing system on this word?
// in any case, we don't want to use it.
tssWordAnn = tssTxtWord;
return false;
}
}
}
// must have found an annotation we can reuse.
fUsedBestPossible = true;
analysis = m_preExistingAnalyses[iAnnClosest];
return true;
}
finally
{
// remove any annotation possibilities that no longer make sense.
if (!SegmentFormCollectionMode)
{
int iBestPossible = possibleIndices.IndexOf(iAnnClosest);
int cRemove = iBestPossible + (fUsedBestPossible ? 1 : 0);
if (cRemove > 0)
(possibleIndices as List<int>).RemoveRange(0, cRemove);
if (possibleIndices.Count == 0)
{
// remove its key from the Dictionary.
m_wordformAnnotationPossibilities.Remove(key);
}
}
}
}
// Make sure we have the right list of occurrences for the specified analysis.
// If we've ever been asked for it, send a PropChanged notification to indicate that it has changed.
public void UpdateAnalysisOccurrences(IAnalysis obj, bool includeChildren)
{
int hvo = obj.Hvo;
int[] values;
if (!m_values.TryGetValue(hvo, out values))
return; // never loaded it, don't unless we get asked for it.
m_values.Remove(hvo); // get rid of dubious value.
int[] newvalues = GetAnalysisOccurrences(hvo, includeChildren);
int flidExact, flidAll;
switch (obj.ClassID)
{
case WfiWordformTags.kClassId:
flidExact = kflidWfExactOccurrences;
flidAll = kflidWfOccurrences;
break;
case WfiAnalysisTags.kClassId:
flidExact = kflidWaExactOccurrences;
flidAll = kflidWaOccurrences;
break;
case WfiGlossTags.kClassId:
flidExact = kflidWgExactOccurrences;
flidAll = kflidWgOccurrences;
break;
default:
return;
}
if (includeChildren)
SendPropChanged(hvo, flidAll, 0, newvalues.Length, values.Length);
else
SendPropChanged(hvo, flidExact, 0, newvalues.Length, values.Length);
SendPropChanged(hvo, kflidOccurrenceCount, 0, 0, 0);
}
/// <summary>
///
/// </summary>
/// <param name="expectedSegForm"></param>
/// <param name="actualSegForm"></param>
/// <param name="segFormContext"></param>
virtual protected void ValidateSegForms(object expectedSegForm, IAnalysis actualSegForm, string segFormContext)
{
return;
}
