public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.XmlDocumentationComment)
{
Opening = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
// look for <reference
if (stream.Current.Type == TokenType.LessThan)
{
var tag = itemFactory.CreateSpecific<XmlDocumentationTag>(this, text, stream);
if (tag.Parse(itemFactory, text, stream))
{
Tag = tag;
Children.Add(tag);
}
else
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
}
}
else
{
while (!IsCommentTerminator(stream.Current.Type))
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
}
}
//if (stream.Current.Type == TokenType.NewLine)
// NewLine = Children.AddCurrentAndAdvance(stream);
}
return Children.Count > 0;
}
protected virtual bool ParseCombinator(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
SelectorCombinator combinator = null;
switch (stream.Current.Type)
{
case TokenType.GreaterThan:
combinator = new ChildCombinator();
break;
case TokenType.Plus:
combinator = new AdjacentSiblingCombinator();
break;
case TokenType.Tilde:
combinator = new GeneralSiblingCombinator();
break;
}
if (combinator != null)
{
if (combinator.Parse(itemFactory, text, stream))
{
Children.Add(combinator);
Combinator = combinator;
}
}
else if (stream.Current.Type != TokenType.OpenCurlyBrace)
{
// whitespace only combinator means no adding to children or parsing
// we just want to know that there was a combinator
if (stream.Current.Start >= (stream.Peek(-1).End + 1))
Combinator = new DescendantCombinator();
}
return Combinator != null;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier)
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.ElementName);
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if ((IsConditionalDirective(text, stream) || IsConditionalContinuationDirective(text, stream)))
{
ParseRule(itemFactory, text, stream);
while (!IsConditionTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Children.Add(item);
ConditionStatements.Add(item);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
while (IsConditionalContinuationDirective(text, stream))
{
var subsequentConditional = itemFactory.CreateSpecific<ConditionalControlDirective>(this, text, stream);
if (!subsequentConditional.Parse(itemFactory, text, stream))
break;
ElseStatements.Add(subsequentConditional);
Children.Add(subsequentConditional);
}
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (IsUrl(text, stream.Current))
{
Function = Children.AddCurrentAndAdvance(stream, SassClassifierType.SystemFunction);
if (stream.Current.Type == TokenType.OpenFunctionBrace)
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
if ((stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString))
{
Url = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
if (Url != null)
Children.Add(Url);
}
else
{
// not using string, so just consume everything until close of url()
while (!IsUrlTerminator(stream.Current.Type))
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
}
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "each"))
{
ParseRule(itemFactory, text, stream);
while (!IsListTerminator(stream.Current.Type))
{
var item = itemFactory.CreateSpecific<ListItem>(this, text, stream);
if (item != null && item.Parse(itemFactory, text, stream))
{
_Items.Add(item);
Children.Add(item);
}
else
{
// bad news bears
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
}
return Children.Count > 0;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Ampersand)
Ampersand = Children.AddCurrentAndAdvance(stream, SassClassifierType.ParentReference);
return Children.Count > 0;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Asterisk)
Asterisk = Children.AddCurrentAndAdvance(stream);
return Children.Count > 0;
}
/// <summary>
/// Verifies that Fortis has been correctly set up.
/// </summary>
/// <param name="itemFactory"></param>
/// <param name="spawnProvider"></param>
/// <param name="itemSearchFactory"></param>
public static void Verify(IItemFactory itemFactory, ISpawnProvider spawnProvider, IItemSearchFactory itemSearchFactory)
{
var verificationFailed = false;
var errorMessages = new StringBuilder();
errorMessages.AppendLine("Fortis intialise verification failed:");
errorMessages.AppendLine();
if (!VerifySpawnProvider(spawnProvider))
{
errorMessages.AppendLine("SpawnProvider is not initialised");
verificationFailed = true;
}
if (!VerifyItemFactory(itemFactory))
{
errorMessages.AppendLine("ItemFactory is not initialised");
verificationFailed = true;
}
if (!VerifyItemSearchFactory(itemSearchFactory))
{
errorMessages.AppendLine("ItemSearchFactory is not initialised");
verificationFailed = true;
}
if (verificationFailed)
{
throw new Exception(errorMessages.ToString());
}
}
protected override void ParseImport(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
{
Filename = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
if (Filename != null)
Children.Add(Filename);
}
else if (UrlItem.IsUrl(text, stream.Current))
{
var url = new UrlItem();
if (url.Parse(itemFactory, text, stream))
{
Url = url;
Children.Add(url);
}
}
while (!IsTerminator(stream.Current.Type))
{
var query = new MediaQuery();
if (!query.Parse(itemFactory, text, stream))
break;
_MediaQueries.Add(query);
Children.Add(query);
}
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
Value = Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier && IsModifier(text.GetText(stream.Current.Start, stream.Current.Length)))
Modifier = Children.AddCurrentAndAdvance(stream);
ParseItem mediaType;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out mediaType))
{
MediaType = mediaType;
Children.Add(mediaType);
}
while (!IsTerminator(text, stream))
{
var expression = itemFactory.CreateSpecific<MediaQueryExpression>(this, text, stream);
if (expression.Parse(itemFactory, text, stream))
{
_Expressions.Add(expression);
Children.Add(expression);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (stream.Current.Type == TokenType.Comma)
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
return Children.Count > 0;
}
static ParseItem CreateSimpleSelector(ComplexItem parent, IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
switch (stream.Current.Type)
{
case TokenType.Ampersand: return new ParentReferenceSelector();
case TokenType.Asterisk: return new UniversalSelector();
case TokenType.Period: return new ClassSelector();
case TokenType.Hash: return new IdSelector();
case TokenType.Identifier: return new TypeSelector();
case TokenType.OpenBrace: return new AttributeSelector();
case TokenType.DoubleColon: return new PseudoElementSelector();
case TokenType.PercentSign: return new ExtendOnlySelector();
}
if (stream.Current.Type == TokenType.Colon)
{
var next = stream.Peek(1);
switch (next.Type)
{
case TokenType.Identifier: return new PseudoClassSelector();
case TokenType.Function: return new PseudoFunctionSelector();
}
}
return null;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (ParseSelectorToken(itemFactory, text, stream))
ParseCombinator(itemFactory, text, stream);
return Children.Count > 0;
}
private ParseItemList Parse(ITextProvider text, IItemFactory itemFactory, ITokenStream stream, IParsingExecutionContext context)
{
var results = new ParseItemList();
while (!context.IsCancellationRequested && stream.Current.Type != TokenType.EndOfFile)
{
int position = stream.Position;
ParseItem item;
if (!itemFactory.TryCreate(null, text, stream, out item))
break;
if (item.Parse(itemFactory, text, stream))
results.Add(item);
// guard against infinite loop (in case token couldn't be handled)
if (stream.Position == position)
stream.Advance();
}
// freeze everything
if (!context.IsCancellationRequested)
foreach (var item in results)
item.Freeze();
return results;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsSelectorTerminator(stream.Current.Type))
{
var selector = itemFactory.CreateSpecific<SelectorGroup>(this, text, stream);
if (!selector.Parse(itemFactory, text, stream))
break;
_Selectors.Add(selector);
Children.Add(selector);
if (stream.Current.Type == TokenType.Comma)
Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var block = itemFactory.CreateSpecific<RuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Block = block;
Children.Add(block);
}
}
return Children.Count > 0;
}
/// <summary>
/// Initialise Fortis with a spawn provider and item factory and verifies the initialisation.
/// </summary>
/// <param name="spawnProvider"></param>
/// <param name="itemFactory"></param>
public static void Initialise(ISpawnProvider spawnProvider, IItemFactory itemFactory)
{
SpawnProvider = spawnProvider;
ItemFactory = itemFactory;
Verify();
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "media"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
while (!IsTerminator(stream.Current.Type))
{
var query = itemFactory.CreateSpecific<MediaQuery>(this, text, stream);
if (query.Parse(itemFactory, text, stream))
{
_Queries.Add(query);
Children.Add(query);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
var block = itemFactory.CreateSpecific<MediaQueryBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "extend"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
var selector = itemFactory.CreateSpecific<SelectorGroup>(this, text, stream);
if (selector.Parse(itemFactory, text, stream))
{
Selector = selector;
Children.Add(selector);
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new OptionalModifier();
if (modifier.Parse(itemFactory, text, stream))
{
Modifier = modifier;
Children.Add(modifier);
}
}
if (stream.Current.Type == TokenType.Semicolon)
Semicolon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
return Children.Count > 0;
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.OpenBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.SquareBrace);
if (stream.Current.Type == TokenType.Identifier)
Attribute = Children.AddCurrentAndAdvance(stream);
if (IsAttributeOperator(stream.Current.Type))
Operator = Children.AddCurrentAndAdvance(stream);
if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
{
Value = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
if (Value != null)
Children.Add(Value);
} else if (stream.Current.Type == TokenType.Identifier)
{
Value = Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
}
if (stream.Current.Type == TokenType.CloseBrace)
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.SquareBrace);
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.LessThan)
{
OpenTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
if (stream.Current.Type == TokenType.Identifier)
{
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
while (!IsTagTerminator(stream.Current.Type))
{
var attribute = itemFactory.CreateSpecific<XmlAttribute>(this, text, stream);
if (!attribute.Parse(itemFactory, text, stream))
break;
Children.Add(attribute);
_Attributes.Add(attribute);
OnAttributeParsed(attribute, text);
}
}
if (stream.Current.Type == TokenType.Slash)
CloseSlash = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
if (stream.Current.Type == TokenType.GreaterThan)
CloseTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
}
return Children.Count > 0;
}
static ParseItem CreateFunctionArgument(ComplexItem parent, IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (parent is MixinReference || parent is SystemFunctionReference || parent is UserFunctionReference)
if (VariableName.IsVariable(text, stream) && stream.Peek(2).Type == TokenType.Colon)
return new NamedFunctionArgument();
return null;
}
public ParseItem CreateItem(IItemFactory itemFactory, ITextProvider text, ITokenStream stream, ComplexItem parent, Type type)
{
CreateParseItem handler;
if (Registry.TryGetValue(type, out handler))
return handler(parent, itemFactory, text, stream);
return null;
}
public static AtRule CreateParsed(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var rule = new AtRule();
if (rule.Parse(itemFactory, text, stream))
return rule;
return null;
}
public virtual bool ParseRule(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
return Rule != null;
}
protected virtual void ParseBlock(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var block = itemFactory.CreateSpecific<RuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
protected override void ParseBlock(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var block = itemFactory.CreateSpecific<KeyframeRuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
KeyframeList = block;
Children.Add(block);
}
}
protected virtual void ParseBody(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
Children.Add(item);
}
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.PercentSign && stream.Peek(1).Type == TokenType.Identifier)
{
Prefix = Children.AddCurrentAndAdvance(stream);
Name = Children.AddCurrentAndAdvance(stream);
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (IsValidName(stream))
{
Dot = Children.AddCurrentAndAdvance(stream, ClassifierType);
Name = Children.AddCurrentAndAdvance(stream, ClassifierType);
}
return Children.Count > 0;
}
/// <summary>
/// Creates a new <see cref="MapFactory"/> instance.
/// </summary>
/// <param name="logger"></param>
/// <param name="serviceProvider"></param>
/// <param name="npcFactory"></param>
public MapFactory(ILogger <MapFactory> logger, IServiceProvider serviceProvider, INpcFactory npcFactory, IItemFactory itemFactory, IMonsterFactory monsterFactory)
{
_logger = logger;
_serviceProvider = serviceProvider;
_npcFactory = npcFactory;
_itemFactory = itemFactory;
_monsterFactory = monsterFactory;
}
public MinilandObjectFactory(IItemFactory itemFactory) => _itemFactory = itemFactory;
public FormAppearanceConverter(IMetadataProvider metadataProvider, IDestMasterRepository destMasterRepository, IItemConverter itemConverter, IItemFactory itemFactory, IFieldProvider fieldProvider, AppSettings appSettings)
: base(destMasterRepository, itemConverter, itemFactory, appSettings)
{
_destMasterRepository = destMasterRepository;
_metadataProvider = metadataProvider;
_fieldProvider = fieldProvider;
_appSettings = appSettings;
}
public ItemFactoryWrapper(ProjectItemElement itemElement, IItemFactory <I, I> wrappedItemFactory)
{
_itemElement = itemElement;
_wrappedItemFactory = wrappedItemFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="IomConnection"/> class.
/// </summary>
/// <param name="iomConnection">The IOM connection instance which minimally implements
/// <c>Aras.IOM.IServerConnection</c>.</param>
/// <param name="itemFactory">The item factory.</param>
public IomConnection(object iomConnection, IItemFactory itemFactory) : this(iomConnection, itemFactory, null)
{
}
public EndTurnCommand(IList <string> cmdArgs, IMainController controller, ICharacterFactory characterFactory, IItemFactory itemFactory) : base(cmdArgs, controller, characterFactory, itemFactory)
{
}
public TestDirectory(string fullPath, IItemFactory itemFactory, short sleepForLoad)
{
(FullPath, _itemFactory) = (fullPath, itemFactory);
Name = IO.Path.GetFileName(fullPath);
_sleepForLoad = sleepForLoad;
}
public ShopService(IUserRepository userRepository, ISlackWebApi slack, IInventoryRepository inventoryRepository, IItemFactory itemFactory)
{
_userRepository = userRepository;
_slack = slack;
_inventoryRepository = inventoryRepository;
_itemFactory = itemFactory;
}
public PeasantBox(IInventoryRepository inventoryRepository, ISlackWebApi slack, IItemFactory itemFactory) : base(inventoryRepository)
{
_inventoryRepository = inventoryRepository;
_slack = slack;
_itemFactory = itemFactory;
Id = ItemId;
Name = "Peasant Box";
Description = "Contains the farmer's set";
Rarity = Rarity.Rare;
Icon = ":mystery_box:";
Price = 200;
IsTradable = false;
IsSellable = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="ArasHttpConnection"/> class using an existing <see cref="IConnection"/>.
/// The existing credential headers should be transferred to the new service in the calling code.
/// Optionally also copy the session cookies to re-use the existing session and prevent a login.
/// </summary>
/// <param name="existingConnection">The existing connection</param>
/// <param name="service">The service.</param>
/// <param name="innovatorServerUrl">The innovator server URL.</param>
/// <param name="itemFactory">The item factory.</param>
/// <remarks>Primarily used in the server environment to get a new connection that won't be rolled back when the transaction encounters an error.</remarks>
public ArasHttpConnection(IConnection existingConnection, HttpClient service, string innovatorServerUrl, IItemFactory itemFactory) : this(service, innovatorServerUrl, itemFactory)
{
Database = existingConnection.Database;
UserId = existingConnection.UserId;
}
public GildedRoseTests()
{
_itemFactory = CreateItemFactory();
}
public TwitterHelper(IItemFactory itemFactory)
{
_itemFactory = itemFactory;
}
protected virtual void ParseDirective(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
}
public CoffeeRepository(DougContext dougContext, IItemFactory itemFactory)
{
_db = dougContext;
_itemFactory = itemFactory;
}
public Store(IItemFactory <TItem, TBorrowerId> factory, int timeout) : base(timeout)
{
this.Factory = factory;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
//if (IsDeclaration(text, stream))
if (stream.Current.Type == TokenType.Identifier || stream.Current.Type == TokenType.OpenInterpolation)
{
var name = itemFactory.CreateSpecific <PropertyName>(this, text, stream);
if (name.Parse(itemFactory, text, stream))
{
Name = name;
Children.Add(name);
}
if (stream.Current.Type == TokenType.Colon)
{
Colon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
while (!IsValueTerminator(stream.Current.Type))
{
ParseItem value;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out value))
{
Values.Add(value);
Children.Add(value);
// bind all unknown values as property values
if (value.ClassifierType == SassClassifierType.Default && value is TokenItem)
{
value.ClassifierType = SassClassifierType.PropertyValue;
}
}
}
// nested property block support
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var block = itemFactory.CreateSpecific <NestedPropertyBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Children.Add(block);
}
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new ImportanceModifier();
if (modifier.Parse(itemFactory, text, stream))
{
Modifier = modifier;
Children.Add(modifier);
}
}
if (stream.Current.Type == TokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
}
return(Children.Count > 0);
}
protected void SetFactory(IItemFactory <TData> factory)
{
_itemFactory = factory ?? new DefaultItemFactory <TData>(this);
}
public ConjuredItemsShould()
{
_itemUpdater = ObjectGraph.UpdaterInstance;
_itemFactory = ObjectGraph.ItemFactoryInstance;
}
public virtual IRenderingModel <TPageItem, TRenderingItem, TRenderingParametersItem> GetRenderingContextItems <TPageItem, TRenderingItem, TRenderingParametersItem>(IItemFactory factory = null)
where TPageItem : IItemWrapper
where TRenderingItem : IItemWrapper
where TRenderingParametersItem : IRenderingParameterWrapper
{
var pageWrapper = SpawnProvider.FromItem <TPageItem>(ContextProvider.PageContextItem);
var renderingWrapper = SpawnProvider.FromItem <TRenderingItem>(ContextProvider.RenderingContextItem);
var validRenderingParametersWrapper = SpawnProvider.FromRenderingParameters <TRenderingParametersItem>(ContextProvider.RenderingItem, ContextProvider.RenderingParameters);
var validPageWrapper = (TPageItem)(pageWrapper is TPageItem ? pageWrapper : null);
var validRenderingWrapper = (TRenderingItem)(renderingWrapper is TRenderingItem ? renderingWrapper : null);
return(new RenderingModel <TPageItem, TRenderingItem, TRenderingParametersItem>(validPageWrapper, validRenderingWrapper, validRenderingParametersWrapper, factory));
}
public AirportController(IAirport airport)
{
this.airport = airport;
this.airplaneFactory = new AirplaneFactory();
this.itemFactory = new ItemFactory();
}
public ItemFactory()
{
this.foodFactory = new FoodFactory();
this.stationaryFactory = new StationaryFactory();
}
/// <summary>
/// Initializes a new instance of the <see cref="GrassOnlyDummyMapLoader"/> class.
/// </summary>
/// <param name="itemFactory">A reference to the item factory.</param>
public GrassOnlyDummyMapLoader(IItemFactory itemFactory)
{
this.ItemFactory = itemFactory;
this.tilesAndLocations = new ConcurrentDictionary <Location, ITile>();
}
public ItemFactoryTests()
{
_itemFactory = CreateItemFactory();
}
public MonsterService(IMonsterRepository monsterRepository, ISlackWebApi slack, IUserService userService, IUserRepository userRepository, IInventoryRepository inventoryRepository, IRandomService randomService, IItemFactory itemFactory, IChannelRepository channelRepository, IMonsterFactory monsterFactory)
{
_monsterRepository = monsterRepository;
_slack = slack;
_userService = userService;
_userRepository = userRepository;
_inventoryRepository = inventoryRepository;
_randomService = randomService;
_itemFactory = itemFactory;
_channelRepository = channelRepository;
_monsterFactory = monsterFactory;
}
public ItemConverter(IFieldFactory fieldFactory, AppSettings appSettings, IMetadataProvider metadataProvider, IItemFactory itemFactory, IDestMasterRepository destMasterRepository, IReporter conversionReporter)
{
_fieldFactory = fieldFactory;
_appSettings = appSettings;
_metadataProvider = metadataProvider;
_itemFactory = itemFactory;
_destMasterRepository = destMasterRepository;
_conversionReporter = conversionReporter;
}
public RegularItemsShould()
{
_itemUpdater = ObjectGraph.UpdaterInstance;
_itemFactory = ObjectGraph.ItemFactoryInstance;
}
public SharedItemStore(IItemFactory <TItem, TBorrowerId> factory, int timeout, int cacheSize) : base(factory, timeout)
{
this.cache = new DictionaryCache <string, TItem>(cacheSize);
base.RegisterCache(this.cache);
}
public FormProcessor(ILogger logger, ISourceMasterRepository sourceMasterRepository, AppSettings appSettings, IMetadataProvider metadataProvider,
IDestMasterRepository destMasterRepository, IItemConverter itemConverter, IItemFactory itemFactory, SubmitConverter submitConverter,
FormAppearanceConverter formAppearanceConverter, SectionAppearanceConverter sectionAppearanceConverter, IReporter conversionReporter)
: base(destMasterRepository, itemConverter, itemFactory, appSettings)
{
_logger = logger;
_sourceMasterRepository = sourceMasterRepository;
_destMasterRepository = destMasterRepository;
_appSettings = appSettings;
_metadataProvider = metadataProvider;
_submitConverter = submitConverter;
_formAppearanceConverter = formAppearanceConverter;
_sectionAppearanceConverter = sectionAppearanceConverter;
_conversionReporter = conversionReporter;
}
public MonsterFactory(IGameResources gameResources, IBehaviorManager behaviorManager, IItemFactory itemFactory)
{
_gameResources = gameResources;
_behaviorManager = behaviorManager;
_itemFactory = itemFactory;
}
public AddItemCommand(IRepository <IItem> itemRepository, IItemFactory itemFactory)
{
this.itemRepository = itemRepository;
this.itemFactory = itemFactory;
}
