/// <summary> /// Creates a StringTemplateGroup instance that manages a set of /// templates defined in a "group file". /// </summary> /// <param name="reader">Input stream for group file data</param> /// <param name="lexer">Lexer to use for breaking up templates into chunks</param> /// <param name="errorListener">Error message sink</param> /// <param name="superGroup">Parent (or super/base) group</param> /// <returns>A StringTemplateGroup instance or null if no group is found</returns> public StringTemplateGroup CreateGroup( TextReader reader, Type lexer, IStringTemplateErrorListener errorListener, StringTemplateGroup superGroup) { return new StringTemplateGroup(reader, lexer, errorListener, superGroup); }
/// <summary> /// Construct an instance that loads groups/interfaces from the single dir or /// multiple dirs specified and uses the specified encoding. /// </summary> /// <remarks> /// If a specified directory is an absolute path, the full path is used to /// locate the template group or interface file. /// /// If a specified directory is a relative path, the path is taken to be /// relative to the location of the stringtemplate assembly itself. /// /// TODO: Check shadow-copying doesn't knock this outta whack. /// </remarks> public EmbeddedResourceGroupLoader( IStringTemplateGroupFactory factory, IStringTemplateErrorListener errorListener, Assembly assembly, string namespaceRoot) { if (assembly == null) throw new ArgumentNullException("assembly", "An assembly must be specified"); if (namespaceRoot == null) throw new ArgumentNullException("namespaceRoot", "A namespace must be specified"); this.factory = (factory == null) ? new DefaultGroupFactory() : factory; this.errorListener = (errorListener == null) ? NullErrorListener.DefaultNullListener : errorListener; this.assembly = assembly; this.namespaceRoot = namespaceRoot; }
public CommonGroupLoader(IStringTemplateErrorListener errorListener, Encoding encoding, params string[] directoryNames) : this(new DefaultGroupFactory(), errorListener, encoding, directoryNames) { }
/** <summary> * Pass a single dir or multiple dirs separated by colons from which * to load groups/interfaces. * </summary> */ public PathGroupLoader( string dirStr, IStringTemplateErrorListener errors ) { _errors = errors; Directories = new ReadOnlyCollection<string>(dirStr.Split(':')); }
/** <summary>Create an interface from the input stream</summary> */ public StringTemplateGroupInterface( TextReader r, IStringTemplateErrorListener errors, StringTemplateGroupInterface superInterface ) { this._listener = errors; SuperInterface = superInterface; ParseInterface( r ); }
public StringTemplateGroup( TextReader r, Type lexer, IStringTemplateErrorListener errors ) : this(r, lexer, errors, (StringTemplateGroup)null) { }
public CommonGroupLoader( IStringTemplateErrorListener errors ) : base(errors) { }
/** <summary> * Pass a single dir or multiple dirs separated by colons from which * to load groups/interfaces. * </summary> */ public PathGroupLoader(string dirStr, IStringTemplateErrorListener errors) { _errors = errors; Directories = new ReadOnlyCollection <string>(dirStr.Split(':')); }
public StringTemplateGroup(TextReader r, IStringTemplateErrorListener errorListener, StringTemplateGroup superGroup) : this(r, null, errorListener, superGroup) { }
/// <summary> /// Create a group from the input stream, but use a nondefault lexer /// to break the templates up into chunks. This is usefor changing /// the delimiter from the default $...$ to <...>, for example. /// </summary> public StringTemplateGroup( TextReader r, Type lexer, IStringTemplateErrorListener errorListener, StringTemplateGroup superGroup) { this.templatesDefinedInGroupFile = true; this.templateLexerClass = (lexer == null) ? typeof(AngleBracketTemplateLexer) : lexer; this.errorListener = (errorListener == null) ? DEFAULT_ERROR_LISTENER : errorListener; this.superGroup = superGroup; this.templateLoader = new NullTemplateLoader(); ParseGroup(r); VerifyInterfaceImplementations(); }
public StringTemplateGroup(TextReader r, IStringTemplateErrorListener errorListener) : this(r, null, errorListener, null) { }
/// <summary> /// Creates a group manager for some templates, all of which are /// loaded via a <see cref="StringTemplateLoader"/>. /// </summary> /// <param name="name"></param> /// <param name="templateLoader"></param> /// <param name="lexer"></param> /// <param name="errorListener"></param> public StringTemplateGroup( string name, StringTemplateLoader templateLoader, Type lexer, IStringTemplateErrorListener errorListener, StringTemplateGroup superGroup) { this.name = name; nameToGroupMap[name] = this; if (templateLoader == null) this.templateLoader = new NullTemplateLoader(); else this.templateLoader = templateLoader; this.templateLexerClass = lexer; if (errorListener == null) this.errorListener = DEFAULT_ERROR_LISTENER; else this.errorListener = errorListener; this.superGroup = superGroup; }
/// <summary> /// Creates a StringTemplateGroup instance that manages a set of /// templates that are accessible via a specified /// <seealso cref="StringTemplateLoader"/>. /// </summary> /// <param name="name">Input stream for group file data</param> /// <param name="templateLoader">Loader for retrieving this group's templates</param> /// <param name="lexer">Lexer to use for breaking up templates into chunks</param> /// <param name="errorListener">Error message sink</param> /// <param name="superGroup">Parent (or super/base) group</param> /// <returns>A StringTemplateGroup instance or null</returns> public StringTemplateGroup CreateGroup( string name, StringTemplateLoader templateLoader, Type lexer, IStringTemplateErrorListener errorListener, StringTemplateGroup superGroup) { return new StringTemplateGroup(name, templateLoader, lexer, errorListener, superGroup); }
/// <summary> /// Construct an instance that loads groups/interfaces from the single dir or /// multiple dirs specified and uses the specified encoding. /// </summary> /// <remarks> /// If a specified directory is an absolute path, the full path is used to /// locate the template group or interface file. /// /// If a specified directory is a relative path, the path is taken to be /// relative to the location of the stringtemplate assembly itself. /// /// TODO: Check shadow-copying doesn't knock this outta whack. /// </remarks> public CommonGroupLoader( IStringTemplateGroupFactory factory, IStringTemplateErrorListener errorListener, Encoding encoding, params string[] directoryNames) { this.factory = factory; this.errorListener = (errorListener == null) ? new NullErrorListener() : errorListener; this.encoding = encoding; foreach (string directoryName in directoryNames) { string fullpath; if (Path.IsPathRooted(directoryName)) { fullpath = directoryName; } else { fullpath = string.Format("{0}/{1}", AppDomain.CurrentDomain.BaseDirectory, directoryName ); } if ( File.Exists(fullpath) || !Directory.Exists(fullpath) ) { Error("group loader: no such dir " + fullpath); } else { if (directories == null) { directories = new ArrayList(); } directories.Add(fullpath); } } }
/** <summary> * Pass a single dir or multiple dirs separated by colons from which * to load groups/interfaces. These are interpreted as relative * paths to be used with CLASSPATH to locate groups. E.g., * If you pass in "org/antlr/codegen/templates" and ask to load * group "foo" it will try to load via classpath as * "org/antlr/codegen/templates/foo". * </summary> */ public CommonGroupLoader( string dirStr, IStringTemplateErrorListener errors ) : base(dirStr, errors) { }
public PathGroupLoader(IStringTemplateErrorListener errors) { _errors = errors; }
public CommonGroupLoader(IStringTemplateErrorListener errors) : base(errors) { }
public StringTemplateGroupInterface( TextReader r, IStringTemplateErrorListener errors ) : this(r, errors, (StringTemplateGroupInterface)null) { }
/** <summary> * Pass a single dir or multiple dirs separated by colons from which * to load groups/interfaces. These are interpreted as relative * paths to be used with CLASSPATH to locate groups. E.g., * If you pass in "org/antlr/codegen/templates" and ask to load * group "foo" it will try to load via classpath as * "org/antlr/codegen/templates/foo". * </summary> */ public CommonGroupLoader(string dirStr, IStringTemplateErrorListener errors) : base(dirStr, errors) { }
public StringTemplateGroup( TextReader r, IStringTemplateErrorListener errors ) : this(r, typeof( AngleBracketTemplateLexer ), errors, (StringTemplateGroup)null) { }
public PathGroupLoader( IStringTemplateErrorListener errors ) { _errors = errors; }
/** <summary> * Create a group from the input stream, but use a nondefault lexer * to break the templates up into chunks. This is usefor changing * the delimiter from the default $...$ to <...>, for example. * </summary> */ public StringTemplateGroup( TextReader r, Type lexer, IStringTemplateErrorListener errors, StringTemplateGroup superGroup ) { this._templatesDefinedInGroupFile = true; // if no lexer specified, then assume <...> when loading from group file if ( lexer == null ) { lexer = typeof( AngleBracketTemplateLexer ); } TemplateLexerClass = lexer; if ( errors != null ) { // always have to have a listener this._listener = errors; } SuperGroup = superGroup; ParseGroup( r ); _nameToGroupMap[_name] = this; VerifyInterfaceImplementations(); }
/// <summary> /// Creates a StringTemplateGroupInterface instance that manages a set of /// template interface definitions defined in a "group interface file". /// </summary> /// <param name="reader">Input stream for group-interface file data</param> /// <param name="errorListener">Error message sink</param> /// <param name="superGroup">Parent (or super/base) group interface</param> /// <returns>A StringTemplateGroupInterface instance or null</returns> public StringTemplateGroupInterface CreateInterface( TextReader reader, IStringTemplateErrorListener errorListener, StringTemplateGroupInterface superInterface) { return new StringTemplateGroupInterface(reader, errorListener, superInterface); }