public WordInfo(PositionLength pl, string oringinalText, MatchParameter parameters)
{
this.Word = oringinalText.Substring(pl.Position, pl.Length);
this.Pos = pl.WordAttr.Pos;
this.Frequency = pl.WordAttr.Frequency;
this.WordType = WordType.SimplifiedChinese;
this.Position = pl.Position;
switch (pl.Level)
{
case 0:
this.Rank = parameters.BestRank;
break;
case 1:
this.Rank = parameters.SecRank;
break;
case 2:
this.Rank = parameters.ThirdRank;
break;
case 3:
this.Rank = parameters.SingleRank;
break;
default:
this.Rank = parameters.BestRank;
break;
}
}
public PanGuTokenizer(AttributeFactory factory, TextReader input, MatchOptions options, MatchParameter parameters)
: base(factory, input)
{
lock (_LockObj)
{
Init();
}
this._options = options;
this._parameters = parameters;
}
public PanGuTokenizer(System.IO.TextReader input, MatchOptions options, MatchParameter parameters)
: base(input)
{
lock (_LockObj)
{
Init();
}
_InputText = base.input.ReadToEnd();
if (string.IsNullOrEmpty(_InputText))
{
char[] readBuf = new char[1024];
int relCount = base.input.Read(readBuf, 0, readBuf.Length);
StringBuilder inputStr = new StringBuilder(readBuf.Length);
while (relCount > 0)
{
inputStr.Append(readBuf, 0, relCount);
relCount = input.Read(readBuf, 0, readBuf.Length);
}
if (inputStr.Length > 0)
{
_InputText = inputStr.ToString();
}
}
if (string.IsNullOrEmpty(_InputText))
{
_WordList = new WordInfo[0];
}
else
{
global::PanGu.Segment segment = new Segment();
ICollection <WordInfo> wordInfos = segment.DoSegment(_InputText, options, parameters);
_WordList = new WordInfo[wordInfos.Count];
wordInfos.CopyTo(_WordList, 0);
}
}
static void Analysis()
{
Segment.Init();
var text = "山东省 济宁市 ， 你好李小龙成龙， 15166793828， 277606";
var options = new MatchOptions
{
ChineseNameIdentify = true,
OnlyChineseName = true,
};
var parameters = new MatchParameter
{
};
Segment segment = new Segment();
ICollection <WordInfo> words = segment.DoSegment(text, options, parameters);
foreach (var word in words)
{
Console.WriteLine(word + "-" + word.WordClass.ToString());
}
Console.ReadKey();
}
/// <summary>
///
/// </summary>
/// <param name="options">分词选项</param>
/// <param name="parameters">分词参数</param>
/// <param name="originalResult">为true不分词,为false分词</param>
public PanGuAnalyzer(MatchOptions options, MatchParameter parameters, bool originalResult = false)
{
Options = options;
MatchParameter = parameters;
_originalResult = originalResult;
}
public Listeners(Socket socket, Client client)
{
socket.On("message", (Action <object>)((data) =>
{
Console.WriteLine("MESSAGE INCOMING");
Message message = new Message(data.ToString());
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Add(message);
});
Console.WriteLine((string)("+++++++++++ MESSAGE:" + message.Text + " " + message.Type + " +++++++++++"));
}));
socket.On("roomSwitched", (data) =>
{
RoomParameter roomParameter = new RoomParameter(data.ToString());
Client.RoomId = roomParameter.RoomId;
Console.WriteLine("+++++++++++ ROOM SWITCHED:" + roomParameter.RoomName + " +++++++++++");
OnChatroomSwitched(roomParameter.RoomName);
});
socket.On("isWaiting", () =>
{
OnIsWaiting();
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
MessageList.Add(new Message("Waiting for an Opponent...", MessageDisplayType.MessageInfo));
});
});
socket.On("gameover", () =>
{
Console.WriteLine("GAMEOVER");
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
Client.IsOnTurn = false;
Client.EmitEndSession();
MessageList.Clear();
OnMatchAbort();
});
});
socket.On("turnBroadcast", (data) =>
{
OnTurnBroadcast(new TurnBroadcast(data.ToString()));
});
socket.On("gameBegins", () =>
{
});
socket.On("cSharpSaveReset", () =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
OnMatchStart(true);
});
});
socket.On("matchParameter", (data) =>
{
MatchParameter mP = new MatchParameter(data.ToString());
Client.OpponentsName = mP.OpponentsName;
Client.OpponentsId = mP.OpponentsId;
Client.IsOnTurn = mP.FirstTurn;
var delayedTurnEmit = System.Threading.Tasks.Task.Run(() => OnSetOnTurn(mP.FirstTurn));
delayedTurnEmit.Wait(TimeSpan.FromMilliseconds(300));
OnSetOnTurn(mP.FirstTurn);
});
socket.On("winnerBroadcast", (data) =>
{
WinnerBroadcast wB = new WinnerBroadcast(data.ToString());
OnMatchResult(wB.animation);
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
if (wB.isWinner)
{
MessageList.Add(new Message("You Won!", MessageDisplayType.ResultWin));
}
else
{
MessageList.Add(new Message("You Lost!", MessageDisplayType.ResultLose));
}
});
});
socket.On("drawBroadcast", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Add(new Message("You both are too dumb to win", MessageDisplayType.ResultDraw));
});
});
socket.On("scoreBroadcast", (data) =>
{
ScoreBroadcast sb = new ScoreBroadcast(data.ToString());
OnScoreBroadcast("You " + sb.clientScore + " : " + sb.opponentsScore + " " + Client.OpponentsName);
});
socket.On("revancheRequest", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
//TODO
MessageList.Add(new Message(Client.OpponentsName + " wants a revanche... Take it or leave it.", MessageDisplayType.RevancheInvitation));
});
});
socket.On("playAgainRequest", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
//TODO
MessageList.Add(new Message(Client.OpponentsName + " wants to play again...", MessageDisplayType.PlayAgainInvitation));
});
});
socket.On("revancheAccepted", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
OnMatchStart(true);
MessageList.Add(new Message(Client.OpponentsName + " wants to kick your ass again!", MessageDisplayType.MessageInfo));
});
});
socket.On("playAgainAccepted", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
OnMatchStart(true);
MessageList.Add(new Message(Client.OpponentsName + " wants to play again!", MessageDisplayType.MessagePrimary));
});
});
socket.On("firstTurn", () =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
});
});
socket.On("setOnTurn", (data) =>
{
var delayedTurnEmit = System.Threading.Tasks.Task.Run(() => OnSetOnTurn((bool)data));
delayedTurnEmit.Wait(TimeSpan.FromMilliseconds(400));
OnSetOnTurn((bool)data);
Client.IsOnTurn = (bool)data;
});
socket.On("opponentFound", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
OnMatchStart(false);
MessageList.Clear();
MessageList.Add(new Message("Opponent found, you're playing against " + data, MessageDisplayType.MessageInfo));
System.Windows.Application.Current.MainWindow.DataContext = new GameViewModel();
});
});
socket.On("idCommit", (data) =>
{
Client.SocketId = data.ToString();
Console.WriteLine("+++++++++++ ID COMMIT:" + data + " +++++++++++");
});
socket.On("updateOnlineUsers", (data) =>
{
OnUpdateOnlineUsers((int)(long)data);
});
}
public PanGuAnalyzer(MatchOptions options, MatchParameter parameters)
: base()
{
_options = options;
_parameters = parameters;
}
public PanGuTokenizer(TextReader input, MatchOptions options, MatchParameter parameters)
: this(AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY, input, options, parameters)
{
}
/// <summary>
/// </summary>
/// <param name="originalResult">
/// Return original string.
/// Don't use when you are doing segments.
/// </param>
public PanGuAnalyzer(bool originalResult, MatchOptions options, MatchParameter parameters, ReuseStrategy reuseStrategy)
: base(reuseStrategy)
{
this.Initialize(originalResult, options, parameters);
}
/// <summary>
/// </summary>
/// <param name="originalResult">
/// Return original string.
/// Don't use when you are doing segments.
/// </param>
public PanGuAnalyzer(bool originalResult, MatchOptions options, MatchParameter parameters)
: base()
{
this.Initialize(originalResult, options, parameters);
}
public PanGuAnalyzer(MatchOptions options, MatchParameter parameters)
: this(false, options, parameters, null)
{
}
public PanGuAnalyzer(MatchOptions options, MatchParameter parameters)
: this(false, options, parameters, Lucene.Net.Analysis.Analyzer.GLOBAL_REUSE_STRATEGY)
{
}
public List <WordInfo> DoSegment(string sentence, MatchOptions options, MatchParameter parameters)
{
return(_segment.DoSegment(sentence, options, parameters).ToList());
}
public List <KeyWord> Segment(string sentence, SegmentOption option)
{
var dict = SingletonDict.Instance;
sentence = sentence.ToLower();
if (dict.NeedInitDict)
{
dict.TransDict = _sqlProvider.GetTransDict();
dict.AliasDict = _sqlProvider.GetAliasDict();
dict.AliasDict.AddRange(GetBoAlias());
dict.NeedInitDict = false;
}
List <WordInfo> words;
MatchOptions matchOptions = new MatchOptions();
matchOptions.IgnoreCapital = true;
if (option.MatchRule == "MinWords")
{
var parameter = new MatchParameter {
Redundancy = 2
};
words = _panGuSegmantService.DoSegment(sentence, matchOptions, parameter);
}
else
{
words = _panGuSegmantService.DoSegment(sentence, matchOptions);
}
words = words.Distinct(new WordAttributeComparer()).ToList();
var keywords = new List <KeyWord>();
if (option.Cc?.Count > 0)
{
keywords.AddRange(from item in words
let cc = item.Pos.ToString().Split(new[] { ", " }, StringSplitOptions.None).ToList()
where option.Cc.Intersect(cc).Any()
select new KeyWord
{
Term = item.Word,
Cc = option.Cc.Intersect(cc).ToList()
});
}
else
{
keywords.AddRange(words.Select(item => new KeyWord
{
Term = item.Word,
Cc = item.Pos.ToString().Split('|').ToList()
}));
}
foreach (var keyword in keywords)
{
//包含同义词
if (option.IncludeAlias)
{
foreach (var key in dict.AliasDict.Keys)
{
if (key.Equals(keyword.Term, StringComparison.OrdinalIgnoreCase))
{
keyword.Aliases.AddRange(dict.AliasDict[key]);
}
}
keyword.Aliases = keyword.Aliases.Distinct().ToList();
}
//包含翻译词
if (option.IncludeTrans)
{
foreach (var key in dict.TransDict.Keys)
{
if (key.Equals(keyword.Term, StringComparison.OrdinalIgnoreCase))
{
keyword.Translates.AddRange(dict.TransDict[key]);
}
}
keyword.Translates = keyword.Translates.Distinct().ToList();
}
}
return(keywords);
}
protected virtual void Initialize(bool originalResult, MatchOptions options, MatchParameter parameters)
{
_originalResult = originalResult;
_options = options;
_parameters = parameters;
}
public PanGuTokenizer(TextReader input, MatchOptions options, MatchParameter parameters, bool originalResult) : this(input, options, parameters)
{
_originalResult = originalResult;
}
public PanGuTokenizer(System.IO.TextReader input, bool originalResult, MatchOptions options, MatchParameter parameters)
: this(input, options, parameters)
{
_OriginalResult = originalResult;
}
