protected XElement ParseSdt(ITagProcessor parentProcessor, XElement sdtElement)
{
ITagParser parser = null;
switch (this.GetTagName(sdtElement).ToLower())
{
case "htmlcontent":
parser = new HtmlContentParser();
break;
case "text":
parser = new TextParser();
break;
case "table":
parser = new TableParser();
break;
case "repeater":
parser = new RepeaterParser();
break;
case "if":
parser = new IfParser();
break;
}
return(parser != null?parser.Parse(parentProcessor, sdtElement) : sdtElement);
}
/// <summary>
/// 添加一个Tag解析器
/// </summary>
/// <param name="parser"></param>
public void AddParser(ITagParser <P, D> parser)
{
if (!this._d.ContainsKey("tag." + parser.TagName))
{
SetValue("tag", parser.TagName, parser);
}
}
/// <summary>
/// 添加一个tag
/// </summary>
/// <param name="tag"></param>
public void AddTag(ITagParser tag)
{
if (!_hosttag.ContainsKey(tag.TagName))
{
_hosttag.Add(tag.TagName, tag);
}
}
public UntagFileCommand(ILogger <TagFileCommand> logger, IFilePathExtractor filePathExtractor, IHashService hashService, ITagParser tagParser, Func <File> newFile)
{
_logger = logger;
_filePathExtractor = filePathExtractor;
_tagParser = tagParser;
_newFile = newFile;
}
private void ParseNodes()
{
while (_textFormatter.IsNotDocumentEnd())
{
if (_normalTagParser.CanParse())
{
_currentParser = _normalTagParser;
CreateNewNode();
}
else
{
foreach (var parser in _specialTagParsers)
{
if (parser.CanParse())
{
_currentParser = parser;
CreateNewNode();
break;
}
}
ParseAsText();
}
//_textFormatter.SkipWhiteSpaces();
}
}
/// <summary>
/// 引擎配置
/// </summary>
/// <param name="conf">配置内容</param>
/// <param name="ctx">默认模板上下文</param>
public static void Configure(EngineConfig conf, TemplateContext ctx)
{
if (conf == null)
{
throw new ArgumentNullException("conf");
}
if (conf.TagParsers == null)
{
conf.TagParsers = conf.TagParsers = Field.RSEOLVER_TYPES;
}
_context = ctx;
ITagParser[] parsers = new ITagParser[conf.TagParsers.Length];
for (Int32 i = 0; i < conf.TagParsers.Length; i++)
{
parsers[i] = (ITagParser)Activator.CreateInstance(Type.GetType(conf.TagParsers[i]));
}
ICache cache = null;
if (!string.IsNullOrEmpty(conf.CachingProvider))
{
cache = (ICache)Activator.CreateInstance(Type.GetType(conf.CachingProvider));
}
Parser.TagTypeResolver resolver = new Parser.TagTypeResolver(parsers);
_engineRuntime = new Runtime(resolver,
cache,
conf);
}
/// <summary>
/// 新增一个解析器
/// </summary>
/// <param name="key"></param>
/// <param name="parser"></param>
public void AddTagParser(ITagParser parser)
{
var k = parser.TagName.ToLower();
if (!_parser.ContainsKey(k))
{
_parser.Add(k, parser);
}
}
public DkimRecordParser(
ITagParser tagParser,
IImplicitProvider <Tag> implicitProvider,
IEvaluator <DkimRecord> ruleEvaluator)
{
_tagParser = tagParser;
_implicitProvider = implicitProvider;
_ruleEvaluator = ruleEvaluator;
}
/// <summary>
/// 加载标签分析器
/// </summary>
/// <param name="arr">解析器类型</param>
private static ITagParser[] LoadParsers(string[] arr)
{
ITagParser[] list = new ITagParser[arr.Length];
for (int i = 0; i < arr.Length; i++)
{
list[i] = CreateInstance <ITagParser>(Type.GetType(arr[i]));
}
return(list);
}
public DmarcRecordParser(ITagParser tagParser,
IRuleEvaluator <DmarcRecord> ruleEvaluator,
IImplicitProvider <Tag> implicitProvider,
IExplainer <Tag> explainer)
{
_tagParser = tagParser;
_ruleEvaluator = ruleEvaluator;
_implicitProvider = implicitProvider;
_explainer = explainer;
}
public UserTagService(
ITagParser tagParser,
IMapperFactory mapperFactory,
IUrlRepository urlRepository,
IUserTagRepository userTagRepository)
{
_tagParser = tagParser;
_mapperFactory = mapperFactory;
_urlRepository = urlRepository;
_userTagRepository = userTagRepository;
}
public TagMarkupBase ParseTag(string markup, int lineNumber, int charPos)
{
ITagParser parser = cache.Find(x => x.CanParseTag(markup));
if (parser == null)
{
throw new ImpressionParseException("Unsupported Tag Found", markup, lineNumber, charPos);
}
return(parser.ParseTag(markup, lineNumber, charPos));
}
public SearchQueryVisitor(SQLiteTag sqLiteTag, ITagParser tagParser)
{
_sqLiteTag = sqLiteTag;
_tagParser = tagParser;
_selectBuilder.AppendLine("SELECT Files.CreatedAt, Files.Hash, Files.Size, FilePaths.Path");
_selectBuilder.AppendLine("FROM Files");
_selectBuilder.AppendLine("JOIN FilePaths ON FilePaths.FileId = Files.Id");
_whereBuilder.Append(WhereStart);
}
protected override void OnValidate()
{
if (!IsActive())
{
base.OnValidate();
}
_curentTagParser = _oldVersionTagParser;
_curentTagParser.InputText = m_Text;
base.OnValidate();
}
public TutorialPostService(IUnitOfWork unitOfWork,
UserManager <IdentityUser> userManager,
IHttpContextAccessor contextAccessor,
IMapper mapper,
ITagParser tagParser)
{
_unitOfWork = unitOfWork;
_loggedUserId = userManager.GetUserId(contextAccessor.HttpContext.User);
_loggedUser = contextAccessor.HttpContext.User;
_mapper = mapper;
_tagParser = tagParser;
}
/// <summary>
/// 根据标签名称获取标签解析器实例
/// </summary>
/// <param name="tagname"></param>
/// <returns></returns>
public ITagParser GetTagParser(string tagname)
{
ITagParser rtn = null;
var k = tagname.ToLower();
if (_parser.ContainsKey(k))
{
var t = _parser[k];
rtn = t;
}
return(rtn);
}
public BlogController(
IUnitOfWork unitOfWork,
UserManager <IdentityUser> userManager,
IHttpContextAccessor contextAccessor,
IMapper mapper,
ITagParser tagParser)
{
_unitOfWork = unitOfWork;
_userManager = userManager;
_loggedUserId = _userManager.GetUserId(contextAccessor.HttpContext.User);
_mapper = mapper;
_tagParser = tagParser;
}
/// <summary>
/// 将中间解析内容写入context
/// </summary>
/// <param name="parser"></param>
/// <param name="key"></param>
/// <param name="content"></param>
public void SetParsedContent(ITagParser parser, string key, object content)
{
string k = parser.TagName.ToLower() + "." + key.ToLower();
if (_content.ContainsKey(k))
{
_content[k] = content;
}
else
{
_content.Add(k, content);
}
}
public ScenarioExtractor(
ISectionExtractor <Given> givenExtractor,
ISectionExtractor <When> whenExtractor,
ISectionExtractor <Then> thenExtractor,
IOutlineParser outlineParser,
ITagParser tagParser)
{
_givenExtractor = givenExtractor;
_whenExtractor = whenExtractor;
_thenExtractor = thenExtractor;
_outlineParser = outlineParser;
_tagParser = tagParser;
}
/// <summary>
/// 初始化标签分析器
/// </summary>
/// <param name="parsers">解析器类型</param>
private static void InitializationParser(String[] parsers)
{
if (parsers == null)
{
parsers = Field.RSEOLVER_TYPES;
}
ITagParser[] tps = new ITagParser[parsers.Length];
for (Int32 i = 0; i < tps.Length; i++)
{
tps[i] = (ITagParser)Activator.CreateInstance(Type.GetType(parsers[i]));
}
_tagResolver = new Parser.TagTypeResolver(tps);
}
/// <summary>
/// 装载标签解析器
/// </summary>
/// <param name="parser">ITagParser</param>
/// <param name="index">索引</param>
public static void RegisterTagParser(ITagParser parser, int index = -1)
{
if (Store.Parsers.Contains(parser))
{
return;
}
if (index < 0)
{
Store.Parsers.Add(parser);
}
else
{
Store.Parsers.IndexOf(parser, index);
}
}
public XLinqRepository(
ILogger <XLinqRepository> logger,
IBadgeParser badgeParser,
ICommentParser commentParser,
IPostHistoryParser postHistoryParser,
IPostParser postParser,
ITagParser tagParser,
IUserParser userParser,
IVoteParser voteParser)
{
this.logger = logger;
this.badgeParser = badgeParser;
this.commentParser = commentParser;
this.postHistoryParser = postHistoryParser;
this.postParser = postParser;
this.tagParser = tagParser;
this.userParser = userParser;
this.voteParser = voteParser;
}
protected override void Init()
{
if (ModuleParameter.GetValue("__tags__") != null &&
ModuleParameter.GetValue("__tags__") is List <ITagParser> )
{
var l = (List <ITagParser>)ModuleParameter.GetValue("__tags__");
ITagParser hjstag = null;
foreach (var t in l)
{
if (t.TagName.ToLower() != "hjs")
{
ModuleData.Context.AddTagParser(t);
}
else
{
hjstag = t;
}
}
if (hjstag != null)
{
ModuleData.Context.AddTagParser(hjstag);
}
else
{
ModuleData.Context.AddTagParser(new HjsTag());
}
}
else
{
//按照先后处理标签的顺序进行标签处理
ModuleData.Context.AddTagParser(new LoadParser());
ModuleData.Context.AddTagParser(new RefParser());
ModuleData.Context.AddTagParser(new CopyParser());
//内嵌标签应优先加载，会用到其它标签的应优先被调用标签加载
ModuleData.Context.AddTagParser(new OutTag());
ModuleData.Context.AddTagParser(new IfTag());
ModuleData.Context.AddTagParser(new ElseIfTag());
ModuleData.Context.AddTagParser(new ElseTag());
ModuleData.Context.AddTagParser(new ForTag());
ModuleData.Context.AddTagParser(new HjsTag());
}
}
/// <summary>
/// 初始化上下文，为后续处理加载对应的解析器,可重载
/// </summary>
/// <param name="context"></param>
protected virtual void Init()
{
ModuleData.Context.AddTagParser(new LoadParser());
ModuleData.Context.AddTagParser(new RefParser());
ModuleData.Context.AddTagParser(new CopyParser());
if (!string.IsNullOrEmpty(GlobalCommon.TagCommon.TagAssemblyPath))
{
Assembly asm = Assembly.Load(GlobalCommon.TagCommon.TagAssemblyPath);
Type[] ts = asm.GetTypes();
foreach (Type t in ts)
{
if (t.IsSubclassOf(typeof(ITagParser)) && !t.IsAbstract && !t.IsInterface)
{
ITagParser l = (ITagParser)Activator.CreateInstance(t, true);
ModuleData.Context.AddTagParser(l);
}
}
}
}
protected override void OnPopulateMesh(VertexHelper toFill)
{
BaseOnPopulateMesh(toFill);
#if UNITY_2019_1_OR_NEWER
var isNewCalculateWay = CheckIsNewCalculateWay();
if (isNewCalculateWay)
{
_curentTagParser = _newVersionTagParser;
_curentTagParser.InputText = m_Text;
}
#endif
var vertices = GetCurrentVertices(toFill);
try
{
DrawSprite(toFill, vertices);
DrawHref(toFill, vertices);
ClearQuadShowError(toFill);
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
}
public FeatureParser(ITagParser tagParser)
{
_tagParser = tagParser;
}
public RenameTagCommand(ILogger <RenameTagCommand> logger, IConsoleWriter consoleWriter, ITagParser tagParser)
{
_logger = logger;
_consoleWriter = consoleWriter;
_tagParser = tagParser;
}
/// <summary>
/// 初始化标签分析器
/// </summary>
/// <param name="parsers">解析器类型</param>
private static void InitializationParser(String[] parsers)
{
if (parsers == null)
{
parsers = Field.RSEOLVER_TYPES;
}
ITagParser[] tps = new ITagParser[parsers.Length];
for (Int32 i = 0; i < tps.Length; i++)
{
tps[i] = (ITagParser)Activator.CreateInstance(Type.GetType(parsers[i]));
}
_tagResolver = new Parser.TagTypeResolver(tps);
}
public MapperFactory(ITagParser tagParser)
{
_tagParser = tagParser;
}
public AddTagCommand(ITagParser tagParser)
{
_tagParser = tagParser;
}
/// <summary>
/// 添加一个标签分析器
/// </summary>
/// <param name="item">标签分析器</param>
public static void Add(ITagParser item)
{
collection.Add(item);
}
public RemoveTagCommand(ITagParser tagParser, IMainDatabase db, ILogger <RemoveTagCommand> logger)
{
_tagParser = tagParser;
_db = db;
_logger = logger;
}
/// <summary>
/// 插入一个标签分析器
/// </summary>
/// <param name="index">插入索引</param>
/// <param name="item">标签分析器</param>
public static void Insert(Int32 index, ITagParser item)
{
collection.Insert(index, item);
}
public MoveTagCommand(ILogger <RenameTagCommand> logger, ITagParser tagParser)
{
_logger = logger;
_tagParser = tagParser;
}
/// <summary>
/// 添加一个标签分析器
/// </summary>
/// <param name="item">标签分析器</param>
public static void Add(ITagParser item)
{
collection.Add(item);
}
/// <summary>
/// 插入一个标签分析器
/// </summary>
/// <param name="index">插入索引</param>
/// <param name="item">标签分析器</param>
public static void Insert(Int32 index, ITagParser item)
{
collection.Insert(index, item);
}
