/// <summary>
/// The details (and possibly the names) of a tag have changed. Update the name lookup tables
/// </summary>
/// <param name="changedTag"></param>
/// <param name="oldName"></param>
/// <param name="oldShortName"></param>
public static void TagDetailsChanged(Tag changedTag, string oldName, string oldShortName)
{
NameLookup.Remove(oldName);
NameLookup[changedTag.Name] = changedTag;
ShortNameLookup.Remove(oldShortName);
ShortNameLookup[changedTag.ShortName] = changedTag;
}
public ISortEnumValue?ParseSortLiteral(IValueNode valueSyntax)
{
if (valueSyntax is null)
{
throw new ArgumentNullException(nameof(valueSyntax));
}
if (valueSyntax is EnumValueNode evn &&
ValueLookup.TryGetValue(evn.Value, out IEnumValue? ev) &&
ev is ISortEnumValue sortEnumValue)
{
return(sortEnumValue);
}
if (valueSyntax is StringValueNode svn &&
NameLookup.TryGetValue(svn.Value, out ev) &&
ev is ISortEnumValue sortEnumValueOfString)
{
return(sortEnumValueOfString);
}
if (valueSyntax is NullValueNode)
{
return(null);
}
throw new SerializationException(
string.Format(
CultureInfo.InvariantCulture,
DataResources.SortingEnumType_Cannot_ParseLiteral,
Name,
valueSyntax.GetType().Name),
this);
}
public ArrayMemberPattern(IEnumerable <IMarshalValueRule> marshallingRules, NameLookup nameLookup, ParsedExpressionBuilder expressionBuilder, CommentGenerator commentGenerator)
{
this.marshallingRules = marshallingRules;
this.nameLookup = nameLookup;
this.expressionBuilder = expressionBuilder;
this.commentGenerator = commentGenerator;
}
public FixedLengthMemberPattern(Dictionary <string, TypeDeclaration> typeData, NameLookup nameLookup, IEnumerable <ConstantDeclaration> constants, IEnumerable <IMarshalValueRule> marshallingRules)
{
this.typeData = typeData;
this.nameLookup = nameLookup;
this.constantsLookup = constants.ToDictionary(x => x.VkName);
this.marshallingRules = marshallingRules;
}
public SimpleMemberPattern(IEnumerable <IMarshalValueRule> marshallingRules, NameLookup nameLookup, Dictionary <string, TypeDeclaration> typeData, CommentGenerator commentGenerator)
{
this.marshallingRules = marshallingRules;
this.nameLookup = nameLookup;
this.typeData = typeData;
this.commentGenerator = commentGenerator;
}
public VerbInfoMemberPattern(Dictionary <string, TypeDeclaration> typeData, NameLookup nameLookup, NamespaceMap namespaceMap, IServiceProvider provider)
{
this.typeData = typeData;
this.nameLookup = nameLookup;
this.namespaceMap = namespaceMap;
this.provider = provider;
}
private SettingsNamespace GetParentNamespace()
{
SettingsNamespace parentNamespace;
if (_creationInfo.UseParent)
{
if (_creationInfo.UseParentSource)
{
var nameLookup = new NameLookup(_node);
var parent = nameLookup.Find(_creationInfo.ParentSourceName);
parentNamespace = parent == null
? SettingsNamespace.None
: Settings.GetNamespace(parent);
}
else
{
var inheritedNamespace = Settings.GetNamespace(_node);
parentNamespace = inheritedNamespace;
}
}
else
{
parentNamespace = SettingsNamespace.None;
}
return(parentNamespace);
}
public ArraySingularMemberPattern(IEnumerable <IMarshalValueRule> marshallingRules, NameLookup nameLookup, ParsedExpressionEqualityCheck expressionEqualityCheck, CommentGenerator commentGenerator, IServiceProvider provider)
{
this.marshallingRules = marshallingRules;
this.nameLookup = nameLookup;
this.expressionEqualityCheck = expressionEqualityCheck;
this.commentGenerator = commentGenerator;
this.provider = provider;
}
private static StatePair <IEnumerable <Token> > Tokenize(IEnumerable <string> arguments, IEnumerable <OptionSpecification> optionSpecs, ParserSettings settings)
{
return(settings.EnableDashDash
? Tokenizer.PreprocessDashDash(
arguments,
args =>
Tokenizer.Tokenize(args, name => NameLookup.Contains(name, optionSpecs, settings.NameComparer)))
: Tokenizer.Tokenize(arguments, name => NameLookup.Contains(name, optionSpecs, settings.NameComparer)));
}
private NameLookup NameLookup_BinarySearchImpl()
{
using var inOrder = NameLookup.OrdererNames.Create(Names, MemoryPool <char> .Shared);
if (!NameLookup.TryCreateBinarySearch(inOrder, MemoryPool <char> .Shared, out var owner, out var mem))
{
throw new Exception();
}
var ret = new NameLookup(NameLookup.Algorithm.BinarySearch, owner, mem);
return(ret);
}
private NameLookup NameLookup_AdaptiveRadixTrieImpl()
{
using var inOrder = NameLookup.OrdererNames.Create(Names, MemoryPool <char> .Shared);
if (!NameLookup.TryCreateAdaptiveRadixTrie(inOrder, MemoryPool <char> .Shared, out var owner, out var mem))
{
throw new Exception();
}
var ret = new NameLookup(NameLookup.Algorithm.AdaptiveRadixTrie, owner, mem);
return(ret);
}
private static Result <IEnumerable <Token>, Error> Tokenize(
IEnumerable <string> arguments,
IEnumerable <OptionSpecification> optionSpecs,
ParserSettings settings)
{
var tokens = settings.EnableDashDash
? Tokenizer.PreprocessDashDash(
arguments,
args =>
Tokenizer.Tokenize(args, name => NameLookup.Contains(name, optionSpecs, settings.NameComparer)))
: Tokenizer.Tokenize(arguments, name => NameLookup.Contains(name, optionSpecs, settings.NameComparer));
var explodedTokens = Tokenizer.ExplodeOptionList(tokens, name => NameLookup.HavingSeparator(name, optionSpecs, settings.NameComparer));
return(explodedTokens);
}
public void Lookup_name_of_sequence_option_with_separator()
{
// Fixture setup
var expected = Maybe.Just(".");
var specs = new[] { new OptionSpecification(string.Empty, "string-seq",
false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), '.', null, typeof(IEnumerable <string>), TargetType.Sequence, string.Empty, string.Empty, new List <string>()) };
// Exercize system
var result = NameLookup.HavingSeparator("string-seq", specs, StringComparer.InvariantCulture);
// Verify outcome
expected.ShouldBeEquivalentTo(result);
// Teardown
}
private static Result <IEnumerable <Token>, Error> Tokenize(
IEnumerable <string> arguments,
IEnumerable <OptionSpecification> optionSpecs,
ParserSettings settings)
{
var normalize = settings.IgnoreUnknownArguments
? toks => Tokenizer.Normalize(toks,
name => NameLookup.Contains(name, optionSpecs, settings.NameComparer) != NameLookupResult.NoOptionFound)
: new Func <IEnumerable <Token>, IEnumerable <Token> >(toks => toks);
var tokens = settings.EnableDashDash
? Tokenizer.PreprocessDashDash(
arguments,
args =>
Tokenizer.Tokenize(args, name => NameLookup.Contains(name, optionSpecs, settings.NameComparer), normalize))
: Tokenizer.Tokenize(arguments, name => NameLookup.Contains(name, optionSpecs, settings.NameComparer), normalize);
var explodedTokens = Tokenizer.ExplodeOptionList(tokens, name => NameLookup.HavingSeparator(name, optionSpecs, settings.NameComparer));
return(explodedTokens);
}
public void TestShipCreation()
{
ComponentDesign engineDesign;// = DefaultStartFactory.DefaultEngineDesign(_game, _faction);
_engineSD = NameLookup.GetTemplateSD(_game, "Engine");
engineDesign = GenericComponentFactory.StaticToDesign(_engineSD, _faction.GetDataBlob <FactionTechDB>(), _game.StaticData);
engineDesign.ComponentDesignAttributes[0].SetValueFromInput(5); //size = 25 power.
_engineComponentDesign = GenericComponentFactory.DesignToDesignEntity(_game, _faction, engineDesign);
_shipClass = ShipFactory.CreateNewShipClass(_game, _faction, "Ob'enn dropship");
Assert.True(_shipClass.FactionOwner == _faction.Guid);
EntityManipulation.AddComponentToEntity(_shipClass, _engineComponentDesign);
EntityManipulation.AddComponentToEntity(_shipClass, _engineComponentDesign);
Vector3 pos = new Vector3(0, 0, 0);
int designEngineNumber = _shipClass.GetDataBlob <ComponentInstancesDB>().GetNumberOfComponentsOfDesign(_engineComponentDesign.Guid);
Assert.AreEqual(2, designEngineNumber);
_ship = ShipFactory.CreateShip(_shipClass, _starSystem, _faction, pos, _starSystem, "Serial Peacemaker");
Assert.AreEqual(designEngineNumber, _ship.GetDataBlob <ComponentInstancesDB>().GetNumberOfComponentsOfDesign(_engineComponentDesign.Guid), "Number of engine components not the same as design");
PropulsionAbilityDB propulsion = _ship.GetDataBlob <PropulsionAbilityDB>();
ShipInfoDB shipInfo = _ship.GetDataBlob <ShipInfoDB>();
Assert.AreEqual(500000, propulsion.TotalEnginePower, "Incorrect TotalEnginePower");
float tonnage1 = _ship.GetDataBlob <ShipInfoDB>().Tonnage;
int expectedSpeed1 = ShipMovementProcessor.MaxSpeedCalc(propulsion.TotalEnginePower, tonnage1);
Assert.AreEqual(expectedSpeed1, propulsion.MaximumSpeed_MS, "Incorrect Max Speed");
EntityManipulation.AddComponentToEntity(_ship, _engineComponentDesign); //add second engine
Assert.AreEqual(750000, propulsion.TotalEnginePower, "Incorrect TotalEnginePower 2nd engine added");
float tonnage2 = _ship.GetDataBlob <ShipInfoDB>().Tonnage;
int expectedSpeed2 = ShipMovementProcessor.MaxSpeedCalc(propulsion.TotalEnginePower, tonnage2);
Assert.AreEqual(expectedSpeed2, propulsion.MaximumSpeed_MS, "Incorrect Max Speed 2nd engine");
}
internal TestGame(int numSystems = 10)
{
GameSettings = new NewGameSettings {
GameName = "Unit Test Game", MaxSystems = numSystems, CreatePlayerFaction = false
};
Game = new Game(GameSettings);
// add a faction:
HumanFaction = FactionFactory.CreateFaction(Game, "New Terran Utopian Empire");
// add a species:
HumanSpecies = SpeciesFactory.CreateSpeciesHuman(HumanFaction, Game.GlobalManager);
// add another faction:
GreyAlienFaction = FactionFactory.CreateFaction(Game, "The Grey Empire");
// Add another species:
GreyAlienSpecies = SpeciesFactory.CreateSpeciesHuman(GreyAlienFaction, Game.GlobalManager);
// Greys Name the Humans.
HumanSpecies.GetDataBlob <NameDB>().SetName(GreyAlienFaction.Guid, "Stupid Terrans");
// Humans name the Greys.
GreyAlienSpecies.GetDataBlob <NameDB>().SetName(HumanFaction.Guid, "Space bugs");
StarSystemFactory starfac = new StarSystemFactory(Game);
Sol = starfac.CreateSol(Game);
Earth = NameLookup.GetFirstEntityWithName(Sol, "Earth"); //Sol.Entities[3]; //should be fourth entity created
EarthColony = ColonyFactory.CreateColony(HumanFaction, HumanSpecies, Earth);
DefaultEngineDesign = DefaultStartFactory.DefaultThrusterDesign(Game, HumanFaction);
DefaultWeaponDesign = DefaultStartFactory.DefaultSimpleLaser(Game, HumanFaction);
DefaultShipDesign = DefaultStartFactory.DefaultShipDesign(Game, HumanFaction);
Vector3 position = Earth.GetDataBlob <PositionDB>().AbsolutePosition_AU;
DefaultShip = ShipFactory.CreateShip(DefaultShipDesign, HumanFaction, position, Earth, Sol, "Serial Peacemaker");
Sol.SetDataBlob(DefaultShip.ID, new TransitableDB());
}
public void Explode_scalar_with_separator_in_odd_args_input_returns_sequence()
{
// Fixture setup
var expectedTokens = new[] { Token.Name("i"), Token.Value("10"), Token.Name("string-seq"),
Token.Value("aaa"), Token.Value("bb"), Token.Value("cccc"), Token.Name("switch") };
var specs = new[] { new OptionSpecification(string.Empty, "string-seq",
false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), ',', null, typeof(IEnumerable <string>), TargetType.Sequence, string.Empty, string.Empty, new List <string>()) };
// Exercize system
var result =
Tokenizer.ExplodeOptionList(
StatePair.Create(
Enumerable.Empty <Token>().Concat(new[] { Token.Name("i"), Token.Value("10"),
Token.Name("string-seq"), Token.Value("aaa,bb,cccc"), Token.Name("switch") }),
Enumerable.Empty <Error>()),
optionName => NameLookup.HavingSeparator(optionName, specs, StringComparer.InvariantCulture));
// Verify outcome
Assert.True(expectedTokens.SequenceEqual(result.Value));
// Teardown
}
public void Explode_scalar_with_separator_in_even_args_input_returns_sequence()
{
// Fixture setup
var expectedTokens = new[] { Token.Name("x"), Token.Name("string-seq"),
Token.Value("aaa"), Token.Value("bb"), Token.Value("cccc"), Token.Name("switch") };
var specs = new[] { new OptionSpecification(string.Empty, "string-seq",
false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), ',', null, string.Empty, string.Empty, new List <string>(), typeof(IEnumerable <string>), TargetType.Sequence) };
// Exercize system
var result =
Tokenizer.ExplodeOptionList(
Result.Succeed(
Enumerable.Empty <Token>().Concat(new[] { Token.Name("x"),
Token.Name("string-seq"), Token.Value("aaa,bb,cccc"), Token.Name("switch") }),
Enumerable.Empty <Error>()),
optionName => NameLookup.HavingSeparator(optionName, specs, StringComparer.InvariantCulture));
// Verify outcome
((Ok <IEnumerable <Token>, Error>)result).Success.ShouldBeEquivalentTo(expectedTokens);
// Teardown
}
private void InitializeClass(string @class)
{
switch (@class)
{
case nameof(Dictionary <string, int>):
DictionaryLookup = DictionaryImpl();
break;
case nameof(System.Array):
ArrayLookup = ArrayImpl();
break;
case nameof(NameLookup.Algorithm.BinarySearch):
BinarySearch = NameLookup_BinarySearchImpl();
break;
case nameof(NameLookup.Algorithm.AdaptiveRadixTrie):
AdaptiveRadixTrie = NameLookup_AdaptiveRadixTrieImpl();
break;
default:
throw new Exception();
}
}
public void Double_dash_force_subsequent_arguments_as_values()
{
// Fixture setup
var expectedResult = new FakeOptionsWithValues
{
StringValue = "str1",
LongValue = 10L,
StringSequence = new[] { "-a", "--bee", "-c" },
IntValue = 20
};
var arguments = new[] { "--stringvalue", "str1", "--", "10", "-a", "--bee", "-c", "20" };
// Exercize system
var result = InstanceBuilder.Build(
() => new FakeOptionsWithValues(),
(a, optionSpecs) =>
Tokenizer.PreprocessDashDash(a,
args => Tokenizer.Tokenize(args, name => NameLookup.Contains(name, optionSpecs, StringComparer.Ordinal))),
arguments,
StringComparer.Ordinal,
CultureInfo.InvariantCulture);
// Verify outcome
expectedResult.ShouldHave().AllProperties().EqualTo(result.Value);
// Teardown
}
public FixedValueMemberPattern(NameLookup nameLookup, Dictionary <string, EnumMapping> enumLookup)
{
this.nameLookup = nameLookup;
this.enumLookup = enumLookup;
}
public MarshalStructValue(NameLookup nameLookup, Dictionary <string, TypeDeclaration> typeData)
{
this.nameLookup = nameLookup;
this.typeData = typeData;
}
/// <summary> /// Return the Tag with the specified name or null if not found /// </summary> /// <param name="name"></param> /// <returns></returns> public static Tag GetTagByName(string name) => NameLookup.GetValueOrDefault(name);
public NextExtensionMemberPattern(NameLookup nameLookup)
{
this.nameLookup = nameLookup;
}
public MarshalPointerValue(NameLookup nameLookup)
{
this.nameLookup = nameLookup;
}
public ArrayLenMemberPattern(ParsedExpressionTokenCheck tokenCheck, NameLookup nameLookup, CommentGenerator commentGenerator)
{
this.tokenCheck = tokenCheck;
this.nameLookup = nameLookup;
this.commentGenerator = commentGenerator;
}
public ArrayLenMemberPattern(ParsedExpressionTokenCheck tokenCheck, NameLookup nameLookup)
{
this.tokenCheck = tokenCheck;
this.nameLookup = nameLookup;
}
public VersionMemberPattern(NameLookup nameLookup)
{
this.nameLookup = nameLookup;
}
public void Double_dash_force_subsequent_arguments_as_values()
{
// Fixture setup
var expectedResult = new Simple_Options_With_Values
{
StringValue = "str1",
LongValue = 10L,
StringSequence = new[] { "-a", "--bee", "-c" },
IntValue = 20
};
var arguments = new[] { "--stringvalue", "str1", "--", "10", "-a", "--bee", "-c", "20" };
// Exercize system
var result = InstanceBuilder.Build(
Maybe.Just <Func <Simple_Options_With_Values> >(() => new Simple_Options_With_Values()),
(a, optionSpecs) =>
Tokenizer.PreprocessDashDash(a,
args => Tokenizer.Tokenize(args, name => NameLookup.Contains(name, optionSpecs, StringComparer.Ordinal))),
arguments,
StringComparer.Ordinal,
false,
CultureInfo.InvariantCulture,
true,
true,
Enumerable.Empty <ErrorType>());
// Verify outcome
expectedResult.Should().BeEquivalentTo(((Parsed <Simple_Options_With_Values>)result).Value);
// Teardown
}
public VersionMemberPattern(NameLookup nameLookup, CommentGenerator commentGenerator)
{
this.nameLookup = nameLookup;
this.commentGenerator = commentGenerator;
}
