public void ParseData(AbstractSectorDataFile data)
{
foreach (SectorData line in data)
{
if (line.dataSegments.Count != 4)
{
eventLogger.AddEvent(new SyntaxError("Invalid number of runway centreline segments", line));
return;
}
if (!CoordinateParser.TryParse(line.dataSegments[0], line.dataSegments[1], out Coordinate firstCoordinate))
{
eventLogger.AddEvent(new SyntaxError("Invalid first runway centreline coordinate", line));
return;
}
if (!CoordinateParser.TryParse(line.dataSegments[2], line.dataSegments[3], out Coordinate secondCoordinate))
{
eventLogger.AddEvent(new SyntaxError("Invalid second runway centreline coordinate", line));
return;
}
// Create the segment once and share it to save memory
RunwayCentrelineSegment segment = new(firstCoordinate, secondCoordinate);
sectorElements.Add(new RunwayCentreline(segment, line.definition, line.docblock, line.inlineComment));
sectorElements.Add(new FixedColourRunwayCentreline(segment, line.definition, line.docblock, line.inlineComment));
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> sectors = sectorElements.Sectors.Select(sector => sector.Name).ToList();
foreach (Sectorline sectorline in sectorElements.SectorLines)
{
foreach (SectorlineDisplayRule rule in sectorline.DisplayRules)
{
if (!sectors.Contains(rule.ControlledSector))
{
string message =
$"Invalid controlled sector {rule.ControlledSector} for SECTORLINE display rule: {rule.GetCompileData(sectorElements)}";
events.AddEvent(new ValidationRuleFailure(message, sectorline));
continue;
}
if (!sectors.Contains(rule.CompareSectorFirst))
{
string message =
$"Invalid first compare sector {rule.CompareSectorFirst} for SECTORLINE display rule: {rule.GetCompileData(sectorElements)}";
events.AddEvent(new ValidationRuleFailure(message, sectorline));
continue;
}
if (!sectors.Contains(rule.CompareSectorSecond))
{
string message =
$"Invalid second compare sector {rule.CompareSectorSecond} for SECTORLINE display rule: {rule.GetCompileData(sectorElements)}";
events.AddEvent(new ValidationRuleFailure(message, sectorline));
}
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> airports = sectorElements.Airports.Select(airport => airport.Icao).ToList();
foreach (Sector sector in sectorElements.Sectors)
{
foreach (SectorGuest guest in sector.Guests)
{
if (guest.DepartureAirport != "*" && !airports.Contains(guest.DepartureAirport))
{
string message =
$"Invalid departure GUEST airport {guest.DepartureAirport} on sector {sector.Name}";
events.AddEvent(new ValidationRuleFailure(message, guest));
break;
}
if (guest.ArrivalAirport != "*" && !airports.Contains(guest.ArrivalAirport))
{
string message =
$"Invalid arrival GUEST airport {guest.ArrivalAirport} on sector {sector.Name}";
events.AddEvent(new ValidationRuleFailure(message, guest));
break;
}
}
}
}
private void TestAirwayCategory(
List <AirwaySegment> airways,
SectorElementCollection sectorElements,
IEventLogger events
)
{
foreach (AirwaySegment airway in airways)
{
if (airway.StartPoint.Type() == Point.TypeIdentifier)
{
if (InvalidPoint(airway.StartPoint.Identifier, sectorElements))
{
string message =
$"Invalid end point {airway.StartPoint.Identifier} on Airway segment for {airway.Identifier}";
events.AddEvent(
new ValidationRuleFailure(message, airway)
);
}
}
if (airway.EndPoint.Type() == Point.TypeIdentifier)
{
if (InvalidPoint(airway.EndPoint.Identifier, sectorElements))
{
string message =
$"Invalid start point {airway.EndPoint.Identifier} on Airway segment for {airway.Identifier}";
events.AddEvent(
new ValidationRuleFailure(message, airway)
);
}
}
}
}
private void TestArtccCategory(
List <ArtccSegment> artccs,
SectorElementCollection sectorElements,
IEventLogger events
)
{
foreach (ArtccSegment artcc in artccs)
{
if (artcc.StartPoint.Type() == Point.TypeIdentifier)
{
if (InvalidPoint(artcc.StartPoint.Identifier, sectorElements))
{
string message =
$"Invalid end point {artcc.StartPoint.Identifier} on ARTCC segment for {artcc.Identifier}";
events.AddEvent(
new ValidationRuleFailure(message, artcc)
);
}
}
if (artcc.EndPoint.Type() == Point.TypeIdentifier)
{
if (InvalidPoint(artcc.EndPoint.Identifier, sectorElements))
{
string message =
$"Invalid start point {artcc.EndPoint.Identifier} on ARTCC segment for {artcc.Identifier}";
events.AddEvent(
new ValidationRuleFailure(message, artcc)
);
}
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> positions = sectorElements.EsePositions.Select(position => position.Identifier).ToList();
foreach (Sector sector in sectorElements.Sectors)
{
foreach (SectorAlternateOwnerHierarchy alt in sector.AltOwners)
{
bool failedValidation = false;
foreach (string position in alt.Owners)
{
if (!positions.Contains(position))
{
string message = $"Invalid ALTOWNER position {position} on sector {sector.Name}";
events.AddEvent(new ValidationRuleFailure(message, alt));
failedValidation = true;
break;
}
}
if (failedValidation)
{
break;
}
}
}
}
private static void ValidateGeoSegment(GeoSegment segment, SectorElementCollection sectorElements, IEventLogger events)
{
if (!ColourValid(segment.Colour, sectorElements))
{
string errorMessage =
$"Invalid colour value {segment.Colour} in GEO segment {segment.GetCompileData(sectorElements)}";
events.AddEvent(new ValidationRuleFailure(errorMessage, segment));
}
}
private static void ValidateBaseGeo(Geo geo, SectorElementCollection sectorElements, IEventLogger events)
{
if (!ColourValid(geo.Colour, sectorElements))
{
string errorMessage =
$"Invalid colour value {geo.Colour} in GEO declaration {geo.GetCompileData(sectorElements)}";
events.AddEvent(new ValidationRuleFailure(errorMessage, geo));
}
}
public static void Validate(IEventLogger events, CompilerArguments arguments)
{
if (arguments.ConfigFiles.Count == 0)
{
events.AddEvent(
new CompilerArgumentError("No config files specified")
);
}
}
private static void ValidateGeoSegment(GeoSegment segment, SectorElementCollection sectorElements, IEventLogger events)
{
if (!PointsValid(segment.FirstPoint, segment.SecondPoint, sectorElements))
{
string message = $"Invalid waypoint on GEO segment: {segment.GetCompileData(sectorElements)}";
events.AddEvent(
new ValidationRuleFailure(message, segment)
);
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (Colour colour in sectorElements.Colours)
{
if (!ColourValidator.IsValidColourInteger(colour.Value.ToString()))
{
events.AddEvent(new ValidationRuleFailure("Invalid colour value " + colour.Value, colour));
}
}
}
public void CheckPoint(RegionPoint point, Region region, SectorElementCollection sectorElements, IEventLogger events)
{
if (!RoutePointValidator.ValidatePoint(point.Point, sectorElements))
{
string message = $"Invalid waypoint {point.Point} on region {region.Name}";
events.AddEvent(
new ValidationRuleFailure(message, region)
);
}
}
private static void ValidateBaseGeo(Geo geo, SectorElementCollection sectorElements, IEventLogger events)
{
if (!PointsValid(geo.FirstPoint, geo.SecondPoint, sectorElements))
{
string message = $"Invalid waypoint on GEO declaration: {geo.GetCompileData(sectorElements)}";
events.AddEvent(
new ValidationRuleFailure(message, geo)
);
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (Label label in sectorElements.Labels)
{
if (!ColourValidator.ColourValid(sectorElements, label.Colour))
{
string errorMessage = $"Invalid colour value {label.Colour} in label {label.Text}";
events.AddEvent(new ValidationRuleFailure(errorMessage, label));
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (CoordinationPoint point in sectorElements.CoordinationPoints)
{
if (!RunwayValid(sectorElements, point.DepartureRunway, point.DepartureAirportOrFixBefore))
{
string message =
$"Invalid departure runway {point.DepartureRunway}/{point.DepartureAirportOrFixBefore} for coordination point: {point.GetCompileData(sectorElements)}";
events.AddEvent(new ValidationRuleFailure(message, point));
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
if (!sectorElements.Colours.Any(colour => colour.Name == "centrelinecolour"))
{
events.AddEvent(
new ValidationRuleFailure(
"Runway centreline colour is not defined",
sectorElements.FixedColourRunwayCentrelines[0]
)
);
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <Sector> duplicates = sectorElements.Sectors.GroupBy(sector => sector.Name)
.Where(group => group.Count() > 1)
.Select(group => group.First())
.ToList();
foreach (Sector duplicate in duplicates)
{
string message = $"Duplicate SECTOR for {duplicate}";
events.AddEvent(new ValidationRuleFailure(message, duplicate));
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (Airport airport in sectorElements.Airports)
{
if (airport.Icao == sectorElements.Info.Airport.AirportIcao)
{
return;
}
}
events.AddEvent(
new ValidationRuleFailure("Invalid airport in INFO definition", sectorElements.Info.Airport)
);
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (Region region in sectorElements.Regions)
{
foreach (RegionPoint point in region.Points)
{
if (point.Colour != null && !ColourValidator.ColourValid(sectorElements, point.Colour))
{
string errorMessage = $"Invalid colour value {point.Colour} for region {region.Name}";
events.AddEvent(new ValidationRuleFailure(errorMessage, point));
}
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> sectors = sectorElements.Sectors.Select(sector => sector.Name).ToList();
foreach (CoordinationPoint point in sectorElements.CoordinationPoints)
{
if (!sectors.Contains(point.FromSector))
{
string message =
$"Invalid FROM sector {point.FromSector} for coordination point: {point.GetCompileData(sectorElements)}";
events.AddEvent(new ValidationRuleFailure(message, point));
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> existingAirports = new List <string>();
foreach (Airport airport in sectorElements.Airports)
{
if (existingAirports.Contains(airport.Icao))
{
events.AddEvent(new ValidationRuleFailure("Duplicate airport " + airport.Icao, airport));
continue;
}
existingAirports.Add(airport.Icao);
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> coloursProcessed = new List <string>();
foreach (Colour colour in sectorElements.Colours)
{
if (coloursProcessed.Contains(colour.Name.ToLower()))
{
events.AddEvent(new ValidationRuleFailure("Duplicate colourm definition " + colour.Name, colour));
continue;
}
coloursProcessed.Add(colour.Name.ToLower());
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (GroundNetwork groundNetwork in sectorElements.GroundNetworks)
{
foreach (GroundNetworkRunwayExit exit in groundNetwork.RunwayExits)
{
if (!RunwayValid(sectorElements, exit.Runway, groundNetwork.Airport))
{
string message = $"Invalid ground network runway {groundNetwork.Airport}/{exit.Runway}";
events.AddEvent(new ValidationRuleFailure(message, exit));
break;
}
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (SidStarRoute sid in sectorElements.SidRoutes)
{
foreach (RouteSegment segment in sid.Segments)
{
if (segment.Colour != null && !ColourValidator.ColourValid(sectorElements, segment.Colour))
{
string errorMessage =
$"Invalid colour value {segment.Colour} in route segment for SID {sid.Identifier}";
events.AddEvent(new ValidationRuleFailure(errorMessage, segment));
}
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> checkedFixes = new List <string>();
foreach (Fix fix in sectorElements.Fixes)
{
if (checkedFixes.Contains(GetFixKey(fix)))
{
events.AddEvent(new ValidationRuleFailure("Duplicate fix found: " + fix.Identifier, fix));
continue;
}
checkedFixes.Add(GetFixKey(fix));
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> keys = new List <string>();
foreach (SidStar sidStar in sectorElements.SidStars)
{
string sidStarKey = GetKey(sidStar);
if (keys.Contains(sidStarKey))
{
events.AddEvent(new ValidationRuleFailure("Duplicate SID/STAR " + sidStarKey, sidStar));
continue;
}
keys.Add(sidStarKey);
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (Sector sector in sectorElements.Sectors)
{
foreach (SectorActive active in sector.Active)
{
if (!RunwayValid(sectorElements, active.Runway, active.Airfield))
{
string message =
$"Invalid ACTIVE runway {active.Airfield}/{active.Runway} on sector {sector.Name}";
events.AddEvent(new ValidationRuleFailure(message, active));
break;
}
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (SidStar sidStar in sectorElements.SidStars)
{
bool airportExists = sectorElements.Airports
.Count(airport => sidStar.Airport == airport.Icao) != 0;
if (!airportExists)
{
string errorMessage =
$"Airport {sidStar.Airport} is not valid for {sidStar.Type}/{sidStar.Identifier}";
events.AddEvent(new ValidationRuleFailure(errorMessage, sidStar));
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
List <string> controllers = sectorElements.EsePositions.Select(position => position.Identifier).ToList();
foreach (Sector sector in sectorElements.Sectors)
{
foreach (SectorGuest guest in sector.Guests)
{
if (!controllers.Contains(guest.Controller))
{
string message = $"Invalid GUEST position {guest.Controller} on sector {sector.Name}";
events.AddEvent(new ValidationRuleFailure(message, guest));
break;
}
}
}
}
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events)
{
foreach (SidStar sidStar in sectorElements.SidStars)
{
foreach (string waypoint in sidStar.Route)
{
if (!RoutePointValidator.ValidateEseSidStarPoint(waypoint, sectorElements))
{
string message =
$"Invalid waypoint {waypoint} on {sidStar.Type} {sidStar.Airport}/{sidStar.Identifier}";
events.AddEvent(
new ValidationRuleFailure(message, sidStar)
);
}
}
}
}
