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; }