private void parseLine()
{
if (_line.Contains(": error"))
{
BuildMessage message = parseMessage(": error");
if (!_results.Errors.Contains(message))
{
_results.AddError(message);
}
}
else if (_line.Contains(": warning"))
{
BuildMessage message = parseMessage(": warning");
if (!_results.Warnings.Contains(message))
{
_results.AddWarning(message);
}
}
else if (_line.StartsWith("\tfatal error "))
{
BuildMessage message = parseMessage("fatal error ");
if (!_results.Errors.Contains(message))
{
_results.AddError(message);
}
}
else if (isSolutionError())
{
BuildMessage message = parseMessage(": Solution file error");
if (!_results.Errors.Contains(message))
{
_results.AddError(message);
}
}
}
TestClient()
{
_logger = new Logger(GetType().Name);
IPAddress ip = Array.FindLast(
Dns.GetHostEntry(string.Empty).AddressList,
a => a.AddressFamily == AddressFamily.InterNetwork);
IPEndPoint ipEndPoint = new IPEndPoint(ip, port);
_logger.Debug("Ip Endpoint");
_logger.Debug(ipEndPoint);
client = new TcpClient();
client.Connect(ipEndPoint);
_logger.Debug("Connected: " + client.Connected);
sendMessage(new ConnectMessage(Environment.UserName));
ConnectMessage msg = (ConnectMessage)ReceiveSingleMessage(client);
this.clientId = msg.playerInfo.userId;
BuildMessage buildMessage = new BuildMessage("test", new Vector(), new Vector());
sendMessage(buildMessage);
Thread.Sleep(2000);
//client.Close();
}
private BuildMessage parseMessage(string type)
{
var message = new BuildMessage();
try
{
if (_line.IndexOf('(') != -1)
{
message.File = Path.Combine(_currentProjectPath, _line.Substring(0, _line.IndexOf('(')).Trim());
var position = _line.Substring(_line.IndexOf('(') + 1, _line.IndexOf(')') - (_line.IndexOf('(') + 1)).Split(',');
message.LineNumber = int.Parse(position[0]);
message.LinePosition = int.Parse(position[1]);
}
message.ErrorMessage = _line.Substring(_line.IndexOf(type) + type.Length,
_line.Length - (_line.IndexOf(type) + type.Length)).Trim();
}
catch (Exception)
{
message.File = "Unknown";
message.LineNumber = 0;
message.LinePosition = 0;
message.ErrorMessage = _line;
}
return(message);
}
public void SendMessage(Message msg)
{
try {
if (!_isDisconnected)
{
if (msg.Type == MessageType.Build)
{
BuildMessage bm = (BuildMessage)msg;
InfoLog.WriteInfo("Sending build message to player: " + this.Id, EPrefix.Test);
InfoLog.WriteInfo("Buildmessage data: " + bm.ToString(), EPrefix.Test);
}
if (msg.Type == MessageType.BuildUnitMessage)
{
BuildUnitMessage bum = (BuildUnitMessage)msg;
InfoLog.WriteInfo("Sending build unit message to player: " + this.Id, EPrefix.Test);
InfoLog.WriteInfo("BuildUnitMessage data: " + bum.ToString(), EPrefix.Test);
}
msg.Serialize(_writeStream);
_writeStream.Flush();
if (msg.Type == MessageType.DoTurn)
{
_tac.Unset(this.Login);
}
}
}
catch (Exception ex) {
InfoLog.WriteException(ex);
ExecuteOnConnectionLost();
}
}
private void mergeBuildList(List<BuildItem> list, string key, BuildMessage[] results)
{
var itemsToRemove = new List<BuildItem>();
foreach (var item in list)
{
var found = false;
foreach (var message in results)
{
var resultItem = new BuildItem(key, message);
if (resultItem.Equals(item))
{
found = true;
break;
}
}
if (!found && item.Key.Equals(key))
itemsToRemove.Add(item);
}
foreach (var item in itemsToRemove)
list.Remove(item);
foreach (var message in results)
{
var item = new BuildItem(key, message);
if (!list.Contains(item))
{
list.Insert(0, item);
}
}
}
private void ProcessRequest(BuildRequest obj)
{
var(idObservable, data) = obj;
idObservable
.Take(1)
.ObserveOnSelf()
.Subscribe(operationId =>
{
Context.Sender.Tell(BuildMessage.GatherData(operationId));
_remaining = 0;
_fail = false;
var toBuild = new List <PreparedBuild>(data.Projects.Count);
toBuild.AddRange(from project in data.Projects
let path = data.FindProjectPath(project)
where !string.IsNullOrWhiteSpace(path)
select new PreparedBuild(data.BuildInfo, project, data, operationId, path));
if (toBuild.Count == 0)
{
Context.Sender.Tell(BuildMessage.NoData(operationId));
return;
}
var agent = 1;
foreach (var preparedBuild in toBuild)
{
_remaining++;
Context.GetOrAdd <BuildAgent>("Agent-" + agent).Forward(preparedBuild);
agent++;
}
});
}
public static void SaveBuildMessage(string fileName, BuildMessage bm)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
if (bm == null)
{
return;
}
using (var writer = new StreamWriter(fileName))
{
JsonUtility.Serialize(
writer,
bm.ToDictionary(
p => p.Key,
p =>
{
using (var sw = new StringWriter())
{
p.Value.Save(sw);
return(sw.ToString());
}
}));
}
}
private void RaiseBuildMessage(object sender, engenious.Content.Pipeline.BuildMessageEventArgs e)
{
if (e.MessageType == engenious.Content.Pipeline.BuildMessageEventArgs.BuildMessageType.Error)
{
FailedBuilds++;
}
BuildMessage?.Invoke(sender, e);
}
/// <summary>
/// Adds a build message to the listview.
/// </summary>
/// <param name="info">The build message to add</param>
private void Bind(BuildMessage info)
{
var lvi = new ListViewItem();
this.Bind(lvi, info);
this.listView1.Items.Add(lvi);
}
/// <summary>
/// Generates the items
/// </summary>
private void GenerateItems()
{
var rnd = new Random();
m_Message = new BuildMessage();
var oldMap = Pandora.Map.Map;
Pandora.Map.Map = (Maps)m_Map;
for (var x = 0; x < m_Rectangle.Width; x++)
{
for (var y = 0; y < m_Rectangle.Height; y++)
{
if (!m_Grid[x, y])
{
continue;
}
var tile = m_TileSet.Tiles[rnd.Next(m_TileSet.Tiles.Count)] as RandomTile;
foreach (int id in tile.Items)
{
var item = new BuildItem();
item.ID = id;
// Hue
var hue = m_Hue;
if (RandomHues != null)
{
// Issue 10 - Update the code to Net Framework 3.5 - http://code.google.com/p/pandorasbox3/issues/detail?id=10 - Smjert
hue = RandomHues.Hues[rnd.Next(RandomHues.Hues.Count)];
// Issue 10 - End
}
item.Hue = hue;
// Location
item.X = m_Rectangle.X + x;
item.Y = m_Rectangle.Y + y;
if (Z != -1)
{
item.Z = Pandora.Map.GetMapHeight(new Point(item.X, item.Y));
}
else
{
item.Z = Z;
}
m_Message.Items.Add(item);
}
}
}
Pandora.Map.Map = oldMap;
}
/// <summary>
/// Binds a build message to the specified listview item.
/// </summary>
/// <param name="lvi">The ListViewItem</param>
/// <param name="info">The BuildMessage</param>
private void Bind(ListViewItem lvi, BuildMessage info)
{
lvi.Tag = info;
int index = 0;
this.BindValue(lvi, index++, info.Description);
this.BindValue(lvi, index++, info.Configuration);
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
var towerBuilder = GameObject.FindObjectOfType <BuildTowerNetworkManager>();
var tower = new BuildMessage();
towerBuilder.CmdBuildTower(tower);
}
}
private void updateMessage(BuildMessage x)
{
foreach (var file in _files.Files)
{
if (compare(file.Tempfile, x.File))
{
x.UpdateFile(file.Original);
}
x.ErrorMessage = x.ErrorMessage.Replace(file.Tempfile, file.Original);
}
}
public static BuildMessageInfo GetPhaseMessageInfo(BuildMessage messages, BuildPhase phase)
{
if (messages == null)
{
return(null);
}
if (!messages.TryGetValue(phase, out BuildMessageInfo message))
{
messages[phase] = message = new BuildMessageInfo();
}
return(message);
}
private static Annotation CreateAnnotation(BuildDetails buildDetails, string repoOwner, string repoName,
string sha, BuildMessage buildMessage, ILookup <string, LogAnalyzerRule> lookup)
{
var filename =
buildDetails.SolutionDetails.GetProjectItemPath(buildMessage.ProjectFile, buildMessage.File)
.TrimStart('/');
var blobHref = BlobHref(repoOwner, repoName, sha, filename);
var logAnalyzerRule = lookup?[buildMessage.Code].FirstOrDefault();
var checkWarningLevel = buildMessage.MessageLevel == BuildMessageLevel.Error
? CheckWarningLevel.Failure
: CheckWarningLevel.Warning;
if (logAnalyzerRule != null)
{
switch (logAnalyzerRule.ReportAs)
{
case ReportAs.AsIs:
break;
case ReportAs.Ignore:
return(null);
case ReportAs.Notice:
checkWarningLevel = CheckWarningLevel.Notice;
break;
case ReportAs.Warning:
checkWarningLevel = CheckWarningLevel.Warning;
break;
case ReportAs.Error:
checkWarningLevel = CheckWarningLevel.Failure;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(new Annotation(filename,
checkWarningLevel,
buildMessage.Code,
$"{buildMessage.Code}: {buildMessage.Message}",
buildMessage.LineNumber,
buildMessage.EndLineNumber,
blobHref));
}
internal void Load(string baseDir)
{
Dependency = IncrementalUtility.LoadDependency(Path.Combine(baseDir, DependencyFile));
Attributes = IncrementalUtility.LoadIntermediateFile <IDictionary <string, FileAttributeItem> >(Path.Combine(baseDir, AttributesFile));
BuildOutputs = IncrementalUtility.LoadIntermediateFile <BuildOutputs>(Path.Combine(baseDir, OutputFile));
Manifest = IncrementalUtility.LoadIntermediateFile <IEnumerable <ManifestItem> >(Path.Combine(baseDir, ManifestFile));
XRefSpecMap = IncrementalUtility.LoadIntermediateFile <IDictionary <string, IEnumerable <XRefSpec> > >(Path.Combine(baseDir, XRefSpecMapFile));
FileMap = IncrementalUtility.LoadIntermediateFile <IDictionary <string, string> >(Path.Combine(baseDir, FileMapFile));
BuildMessage = IncrementalUtility.LoadBuildMessage(Path.Combine(baseDir, BuildMessageFile));
foreach (var processor in Processors)
{
processor.Load(baseDir);
}
}
private static BuildMessageInfo GetPhaseMessageInfo(BuildMessage messages)
{
if (messages == null)
{
return null;
}
BuildMessageInfo message;
if (!messages.TryGetValue(BuildPhase.PreBuildBuild, out message))
{
messages[BuildPhase.PreBuildBuild] = message = new BuildMessageInfo();
}
return message;
}
private void HandleBuildMessage(BuildMessage message)
{
if (!message.IsSuccessfulBuild)
{
return;
}
// we should update collection view from another thread
// https://stackoverflow.com/a/18336392/2219089
Application.Current.Dispatcher.Invoke(delegate
{
Map[message.Coordinates.Coordinate_Y][message.Coordinates.Coordinate_X] = message.RouteCard;
});
OnPropertyChanged(nameof(Map));
}
private static BuildMessageInfo GetPhaseMessageInfo(BuildMessage messages)
{
if (messages == null)
{
return(null);
}
BuildMessageInfo message;
if (!messages.TryGetValue(BuildPhase.PreBuildBuild, out message))
{
messages[BuildPhase.PreBuildBuild] = message = new BuildMessageInfo();
}
return(message);
}
public void Should_serialize_chache_build_message()
{
var item = new BuildMessage()
{
ErrorMessage = "message", File = "file", LineNumber = 1, LinePosition = 2
};
var message = new CacheBuildMessage("project", item);
var output = serializeDeserialize(message);
Assert.AreEqual("project", output.Project);
Assert.AreEqual("message", output.BuildItem.ErrorMessage);
Assert.AreEqual("file", output.BuildItem.File);
Assert.AreEqual(1, output.BuildItem.LineNumber);
Assert.AreEqual(2, output.BuildItem.LinePosition);
}
public void Should_not_be_equal()
{
var message1 = new BuildMessage();
message1.ErrorMessage = "error message";
message1.File = "file";
message1.LineNumber = 15;
message1.LinePosition = 20;
var message2 = new BuildMessage();
message2.ErrorMessage = "another error message";
message2.File = "file";
message2.LineNumber = 17;
message2.LinePosition = 10;
message1.Equals(message2).ShouldBeFalse();
}
public void CmdBuildTower(BuildMessage message)
{
// receives message from client
// client has the intent to build a tower
// validate that player can build tower
// i.e.
// Does player have enough resources?
// Is location available?
// Is location valid? (meaning does it block the path? Is there something at that location?)
//
// call rpc method so that clients build the actual tower in their own game instance
RpcBuildTower(message);
}
protected override void OnMessageBuild(BuildMessage bm)
{
//InfoLog.WriteInfo("MessageBuild", EPrefix.SimulationInfo);
InfoLog.WriteInfo("OnMessageBuild", EPrefix.Test);
InfoLog.WriteInfo("BuildingType: " + bm.BuildingType + " CreatorID: " + bm.CreatorID, EPrefix.Test);
BuildingData bd = GlobalSettings.Wrapper.buildingsMap[bm.BuildingType];
if (!Building.CheckBuildPosition(bd, bm.Position, _map, bm.IdPlayer))
{
if (InvalidBuild != null)
{
InfoLog.WriteInfo("Buidling: " + bm.BuildingType + " was not built because of location", EPrefix.BMan);
InvalidBuild(bm.CreatorID);
/*int cost = GlobalSettings.Wrapper.buildingsMap[bm.BuildingType].Cost;
* p.Credits += cost;
* OnCreditsUpdate(cost);*/
}
return;
}
int playerCredits = players[bm.IdPlayer].Credits;
int buildingCost = GlobalSettings.Wrapper.buildingsMap[bm.BuildingType].Cost;
if (playerCredits < buildingCost)
{
InfoLog.WriteInfo("Buidling: " + bm.BuildingType + " was not built because of credits", EPrefix.BMan);
if (InvalidBuild != null)
{
InvalidBuild(bm.CreatorID);
}
return;
}
players[bm.IdPlayer].Credits -= buildingCost;
if (OnCreditsUpdate != null)
{
OnCreditsUpdate(bm.IdPlayer, buildingCost);
}
Building b = AddBuilding(bm.IdPlayer, bm.CreatorID, bm.BuildingType, bm.Position);
b.State = Building.BuildingState.constructing;
b.BuildStatus = new BuildStatus(bm.CreatorID, bm.BuildingType, b.BuildingData.BuildSpeed, BuildType.Building);
UpdatePowerManagement(b);
InfoLog.WriteInfo("OnMessageBuildEnd", EPrefix.BMan);
//OnBuildingCompleted(b, bm.CreatorID);
//194.29.178.207
}
public BuildResults Build(string filename, string outputPath)
{
string launcherFilename = Path.GetFileName(LauncherPath);
_results = new BuildResults();
try
{
if (filename == null)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.InvalidInput"));
return(_results);
}
if (String.IsNullOrEmpty(outputPath))
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.NoOutputPath"));
return(_results);
}
// Copy setup.bin to the output directory
string strOutputExe = System.IO.Path.Combine(outputPath, launcherFilename);
if (!CopyLauncherToOutputDirectory(strOutputExe))
{
// Appropriate messages should have been stuffed into the results already
return(_results);
}
var resourceUpdater = new ResourceUpdater();
resourceUpdater.AddStringResource(LAUNCHER_RESOURCE_TABLE, LAUNCHER_RESOURCENAME, filename);
if (!resourceUpdater.UpdateResources(strOutputExe, _results))
{
return(_results);
}
_results.SetKeyFile(launcherFilename);
_results.BuildSucceeded();
}
catch (Exception ex)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.General", ex.Message));
}
return(_results);
}
} //Number of errors
private void AddMessage(BuildMessage msg)
{
Messages.Add(msg);
if (msg.Type == BuildMessageType.Error)
{
ErrorCount++;
//An error limit - if reached we stop compilation
if (Messages.Count >= ERROR_LIMIT)
{
//Generate "too many errors" error message and terminate
Messages.Add(new BuildMessage(CompilerErrors.TooManyErrors, BuildMessageType.Error,
(int)CompilerError.TooManyErrors, msg.Line, msg.Column, unit.FileName));
throw new TerminationException();
}
}
}
public void Should_not_be_equal()
{
var message1 = new BuildMessage();
message1.ErrorMessage = "error message";
message1.File = "file";
message1.LineNumber = 15;
message1.LinePosition = 20;
var message2 = new BuildMessage();
message2.ErrorMessage = "another error message";
message2.File = "file";
message2.LineNumber = 17;
message2.LinePosition = 10;
message1.Equals(message2).ShouldBeFalse();
}
private void parseLine()
{
if (_line.Contains(": error"))
{
BuildMessage message = parseMessage(": error");
if (!_results.Errors.Contains(message))
{
_results.AddError(message);
}
}
else if (_line.Contains(": warning"))
{
BuildMessage message = parseMessage(": warning");
if (!_results.Warnings.Contains(message))
{
_results.AddWarning(message);
}
}
}
public static void SaveBuildMessage(string fileName, BuildMessage bm)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
if (bm == null)
{
return;
}
using (var writer = new StreamWriter(fileName))
{
JsonUtility.Serialize(
writer,
bm.ToDictionary(
p => p.Key,
p => SaveSerializedBuildMessageInfo(p.Value, Path.GetDirectoryName(fileName))));
}
}
public static BuildMessage LoadBuildMessage(string file)
{
if (string.IsNullOrEmpty(file))
{
return(null);
}
using (var reader = new StreamReader(file))
{
var bm = new BuildMessage();
var content = JsonUtility.Deserialize <Dictionary <BuildPhase, string> >(reader);
foreach (var c in content)
{
using (var sr = new StreamReader(Path.Combine(Path.GetDirectoryName(file), c.Value)))
{
bm[c.Key] = BuildMessageInfo.Load(sr);
}
}
return(bm);
}
}
private Maybe <AgentCompled> OnBuild(Maybe <PreparedBuild> mayBuild)
{
var agentName = Context.Self.Path.Name + ": ";
return(MatchMay(
from build in mayBuild
select Try(() =>
from step1 in MayTell(Context.Sender, BuildMessage.GatherData(build.Operation, agentName))
from data in GetData(build)
from step2 in MayTell(Context.Sender, BuildMessage.GenerateLangFiles(build.Operation, agentName))
from a in GenerateJson(data, build.TargetPath)
from step3 in MayTell(Context.Sender, BuildMessage.GenerateCsFiles(build.Operation, agentName))
from b in GenerateCode(data, build.TargetPath)
from final in MayTell(Context.Sender, BuildMessage.AgentCompled(build.Operation, agentName))
select new AgentCompled(false, Maybe <Exception> .Nothing, build.Operation)),
e => May(new AgentCompled(true, May(e), mayBuild.Value.Operation))));
}
public void CreateBuilding(Position pos, short buildingId, int creatorID)
{
BuildingData bd = GlobalSettings.Wrapper.buildingsMap[buildingId];
if (!Building.CheckBuildPosition(bd, pos, _sim.Map, CurrentPlayer.Id))
{
if (OnBadLocation != null)
{
OnBadLocation(creatorID);
}
return;
}
BuildMessage bm = (BuildMessage)Yad.Net.Client.Utils.CreateMessageWithSenderId(MessageType.Build);
//bm.BuildingID = CurrentPlayer.GenerateObjectID();//don't set object id here! it's not reflected in other simulations
bm.IdPlayer = CurrentPlayer.Id;
bm.BuildingType = buildingId;
bm.CreatorID = creatorID;
bm.Type = MessageType.Build;
bm.Position = pos;
Connection.Instance.SendMessage(bm);
// building is not built yet
//IncreaseBuildingCounter(buildingId);
//TODO: need help - what is this for?
/*
* AddUnitCreation(bm.BuildingType);
*
* foreach (TechnologyDependence techRef in sim.GameSettingsWrapper.racesMap[currPlayer.Race].TechnologyDependences) {
* short ids = sim.GameSettingsWrapper.namesToIds[techRef.BuildingName];
* if (gf.IsStripContainingBuilding(ids) == true) continue;
* if (CheckReqBuildingsToAddNewBuilding(techRef.RequiredBuildings)) {
* // adds new building to strip
* OnNewBuilding(ids, currPlayer.Race);
* }
* }
*/
}
private BuildMessage parseMessage(string type)
{
var message = new BuildMessage();
try
{
message.File = Path.Combine(_currentProjectPath, _line.Substring(0, _line.IndexOf('(')).Trim());
var position = _line.Substring(_line.IndexOf('(') + 1, _line.IndexOf(')') - (_line.IndexOf('(') + 1)).Split(',');
message.LineNumber = int.Parse(position[0]);
message.LinePosition = int.Parse(position[1]);
message.ErrorMessage = _line.Substring(_line.IndexOf(type) + type.Length,
_line.Length - (_line.IndexOf(type) + type.Length)).Trim();
}
catch (Exception)
{
message.File = "Unknown";
message.LineNumber = 0;
message.LinePosition = 0;
message.ErrorMessage = _line;
}
return message;
}
private bool CopyLauncherToOutputDirectory(string strOutputExe)
{
if (!FileSystems.Default.FileExists(LauncherPath))
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.MissingLauncherExe", LauncherPath));
return(false);
}
try
{
EnsureFolderExists(Path.GetDirectoryName(strOutputExe));
File.Copy(LauncherPath, strOutputExe, true);
ClearReadOnlyAttribute(strOutputExe);
}
catch (Exception ex) when(ExceptionHandling.IsIoRelatedException(ex))
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.CopyError", LauncherPath, strOutputExe, ex.Message));
return(false);
}
return(true);
}
private static void WriteXmlBuildMessage(XmlWriter xmlWriter, BuildMessage message)
{
if (message.Type == MessageType.Error)
{
xmlWriter.WriteStartElement("error");
}
else
{
xmlWriter.WriteStartElement("warning");
}
xmlWriter.WriteAttributeString("message", message.Description);
xmlWriter.WriteAttributeString("code", message.Code); // may be null or empty
if (message.Line > 0 || !string.IsNullOrEmpty(message.File))
{
xmlWriter.WriteAttributeString("name", message.File);
xmlWriter.WriteAttributeString("line", message.Line.ToString());
}
xmlWriter.WriteEndElement();
}
/// <remarks/>
public void BeginBuildAsync(BuildMessage message) {
this.BeginBuildAsync(message, null);
}
/// <remarks/>
public System.IAsyncResult BeginBeginBuild(BuildMessage message, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("BeginBuild", new object[] {
message}, callback, asyncState);
}
private void mergeBuildList(Dictionary<int, BuildItem> list, string key, BuildMessage[] results)
{
var itemsToRemove = new List<int>();
var buildResults = new Dictionary<int, BuildItem>();
results.ToList().ForEach(x =>
{
var resultItem = new BuildItem(key, x);
buildResults.Add(resultItem.GetHashCode(), resultItem);
});
foreach (var item in list)
{
if (item.Value.Key.Equals(key) && !buildResults.ContainsKey(item.Key))
{
//Debug.WriteDebug("Removing old build item from {0} in {1}, {2} {3}:{4}", item.Value.Key, item.Value.Value.File, item.Value.Value.ErrorMessage, item.Value.Value.LineNumber, item.Value.Value.LinePosition);
itemsToRemove.Add(item.Key);
}
}
foreach (var item in itemsToRemove)
list.Remove(item);
foreach (var item in buildResults)
{
if (!list.ContainsKey(item.Key))
{
//Debug.WriteDebug("Adding new build item from {0} in {1}, {2} {3}:{4}", item.Value.Key, item.Value.Value.File, item.Value.Value.ErrorMessage, item.Value.Value.LineNumber, item.Value.Value.LinePosition);
//list.Insert(0, item);
list.Add(item.Key, item.Value);
}
}
}
private void updateMessage(BuildMessage x)
{
foreach (var file in _files.Files)
{
if (compare(file.Tempfile, x.File))
x.UpdateFile(file.Original);
x.ErrorMessage = x.ErrorMessage.Replace(file.Tempfile, file.Original);
}
}
internal void Load(string baseDir)
{
Dependency = IncrementalUtility.LoadDependency(Path.Combine(baseDir, DependencyFile));
Attributes = IncrementalUtility.LoadIntermediateFile<IDictionary<string, FileAttributeItem>>(Path.Combine(baseDir, AttributesFile));
BuildOutputs = IncrementalUtility.LoadIntermediateFile<BuildOutputs>(Path.Combine(baseDir, OutputFile));
Manifest = IncrementalUtility.LoadIntermediateFile<IEnumerable<ManifestItem>>(Path.Combine(baseDir, ManifestFile));
XRefSpecMap = IncrementalUtility.LoadIntermediateFile<IDictionary<string, IEnumerable<XRefSpec>>>(Path.Combine(baseDir, XRefSpecMapFile));
FileMap = IncrementalUtility.LoadIntermediateFile<IDictionary<string, string>>(Path.Combine(baseDir, FileMapFile));
BuildMessage = IncrementalUtility.LoadBuildMessage(Path.Combine(baseDir, BuildMessageFile));
foreach (var processor in Processors)
{
processor.Load(baseDir);
}
}
/// <summary>
/// Binds a build message to the specified listview item.
/// </summary>
/// <param name="lvi">The ListViewItem</param>
/// <param name="info">The BuildMessage</param>
private void Bind(ListViewItem lvi, BuildMessage info)
{
lvi.Tag = info;
int index = 0;
this.BindValue(lvi, index++, info.Description);
this.BindValue(lvi, index++, info.Configuration);
}
/// <summary>
/// Adds a build message to the listview.
/// </summary>
/// <param name="info">The build message to add</param>
private void Bind(BuildMessage info)
{
var lvi = new ListViewItem();
this.Bind(lvi, info);
this.listView1.Items.Add(lvi);
}
/// <remarks/>
public void BeginBuildAsync(BuildMessage message, object userState) {
if ((this.BeginBuildOperationCompleted == null)) {
this.BeginBuildOperationCompleted = new System.Threading.SendOrPostCallback(this.OnBeginBuildOperationCompleted);
}
this.InvokeAsync("BeginBuild", new object[] {
message}, this.BeginBuildOperationCompleted, userState);
}
private void mergeBuildList(List<BuildItem> list, string key, BuildMessage[] results)
{
var itemsToRemove = new List<BuildItem>();
foreach (var item in list)
{
var found = false;
foreach (var message in results)
{
var resultItem = new BuildItem(key, message);
if (resultItem.Equals(item))
{
found = true;
break;
}
}
if (!found && item.Key.Equals(key))
{
Debug.WriteDebug("Removing old build item from {0} in {1}, {2} {3}:{4}", item.Key, item.Value.File, item.Value.ErrorMessage, item.Value.LineNumber, item.Value.LinePosition);
itemsToRemove.Add(item);
}
}
foreach (var item in itemsToRemove)
list.Remove(item);
foreach (var message in results)
{
var item = new BuildItem(key, message);
if (!list.Contains(item))
{
Debug.WriteDebug("Adding new build item from {0} in {1}, {2} {3}:{4}", item.Key, item.Value.File, item.Value.ErrorMessage, item.Value.LineNumber, item.Value.LinePosition);
list.Insert(0, item);
}
}
}
public BuildItem(string key, BuildMessage value)
{
Key = key;
Value = value;
}
