private string GenerateInterfaceInternal(IBSharpClass e, Dictionary<string, IBSharpClass> refcache) { var sb = new StringBuilder(); sb.AppendLine(CommonHeader); sb.AppendLine("using System;"); sb.AppendLine("using System.Collections.Generic;"); foreach (var u in e.Compiled.Elements("using")) { if (u.Attr("code") != e.Namespace) { sb.AppendLine("using " + u.Attr("code") + ";"); } } sb.AppendLine("namespace " + e.Namespace + " {"); sb.AppendLine("\t/// <summary>\r\n\t///\t" + e.Compiled.Attr("name") + "\r\n\t/// </summary>"); var implements = string.Join(", ", e.Compiled.Elements("implements").Select(_ => _.Attr("code")).Where(_=>_!="I"+e.Name)); if (!string.IsNullOrWhiteSpace(implements)) { implements = " : " + implements; } sb.AppendLine("\tpublic partial interface I" + e.Name + implements + " {"); foreach (var field in e.Compiled.Elements()) { if (field.Name.LocalName == "using") continue; if (field.Name.LocalName == "implements") continue; if (field.Name.LocalName == "interface") continue; GenerateInterfaceField(e, field, refcache, sb); } sb.AppendLine("\t}"); sb.AppendLine("}"); return sb.ToString(); }
/// <summary> /// /// </summary> /// <param name="targetclasses"></param> /// <returns></returns> protected override IEnumerable<Production> InternalGenerate(IBSharpClass[] targetclasses){ var enums = targetclasses.Where(_ => _.Compiled.Attr("enum").ToBool() && !_.Compiled.Attr("nocode").ToBool() ).ToArray(); var structs = targetclasses.Where(_ => _.Compiled.Attr("struct").ToBool() && !_.Compiled.Attr("nocode").ToBool() && !_.Compiled.ContainsElement("interface")).ToArray(); var interfaces = _context.Get(BSharpContextDataType.Working).Where(_ => _.Compiled.ContainsElement("interface")).ToArray(); var refcache = targetclasses.ToDictionary(_ => _.Name, _=>_); foreach (var @enum in enums){ if(@enum.Compiled.Attr("generate")=="false")continue; if(@enum.Compiled.Attr("generate-app-cs")=="false")continue; yield return GenerateEnum(@enum, refcache); } foreach (var @struct in structs) { if (@struct.Compiled.Attr("generate") == "false") continue; if (@struct.Compiled.Attr("generate-app-cs") == "false") continue; yield return GenerateStruct(@struct, refcache); } foreach (var @interface in interfaces) { if (@interface.Compiled.Attr("generate") == "false") continue; yield return GenerateInterface(@interface, refcache); } }
/// <summary> /// </summary> /// <param name="targetclasses"></param> /// <returns></returns> protected override IEnumerable<Production> InternalGenerate(IBSharpClass[] targetclasses){ var genfactory = new Production{ FileName = "Adapters/Model.cs", GetContent = () => new BaseModelWriter(Model).ToString() }; yield return genfactory; }
/// <summary> /// Создает запись для класса /// </summary> /// <param name="cls"></param> /// <param name="context"></param> /// <returns></returns> protected override XElement CreateClassRecord(IBSharpClass cls, IBSharpContext context) { var result = GetIndexElement(cls); var src = new XElement(cls.Compiled) { Name = "Compiled" }; result.Add(src); return result; }
private Production GenerateInterface(IBSharpClass @interface, Dictionary <string, IBSharpClass> refcache) { var filename = @interface.Compiled.Element("interface").Attr("folder") + "/I" + @interface.Name + ".cs"; return(new Production { FileName = filename, GetContent = () => GenerateInterfaceInternal(@interface, refcache) }); }
private void ReadInterfaces(IBSharpClass c, XElement xml) { foreach (string e in xml.Elements("implements").Select(_ => _.Attr("code")).Distinct() .OrderBy(_ => _.StartsWith("I") ? "ZZZ" + _ : _)) { CSharpInterfaces.Add(e); } }
private void ReadDataTypes(IBSharpClass c, XElement xml) { foreach (XElement dt in xml.Elements("datatype")) { DataType dtypeDef = new DataType().Setup(c, dt); DataTypeMap[dtypeDef.Code] = dtypeDef; } }
/// <summary> /// /// </summary> /// <param name="model"></param> /// <param name="cls"></param> /// <returns></returns> public virtual T Setup(ApplicationModel model, IBSharpClass cls) { this.Class = cls; this.Model = model; this.Code = Class.Name; this.Name = Class.Compiled.GetName(); return((T)this); }
private Production GenerateEnum(IBSharpClass e, Dictionary <string, IBSharpClass> refcache) { var result = new Production { FileName = "DataTypes/" + e.FullName + ".cs", GetContent = () => GenerateInternal(e) }; return(result); }
private Production GenerateStruct(IBSharpClass e, Dictionary <string, IBSharpClass> refcache) { var usenames = this.Project.Definition.Attr("NoFullNames").ToBool(); var result = new Production { FileName = "DataTypes/" + (usenames?e.Name:e.FullName) + ".cs", GetContent = () => GenerateInternal(e, refcache) }; return(result); }
/// <summary> /// Перекрыть для настройки DBObject из XML /// </summary> /// <param name="bscls"></param> /// <param name="xml"></param> /// <param name="model"></param> /// <param name="cls"></param> public override SqlObject Setup(PersistentModel model, PersistentClass cls, IBSharpClass bscls, XElement xml) { base.Setup(model, cls, bscls, xml); WithIndex = xml.Attr("withidx", "0").ToBool(); FileSize = xml.Attr("filesize", "10").ToInt(); FileCount = xml.Attr("filecount", "1").ToInt(); IsDefault = xml.Attr("isdefault", "0").ToBool(); return(this); }
public void WriteJson(IBSharpClass cls, object json = null, IList<string> opts =null) { json = json ?? new {}; var path = Path.Combine(Project.RootDirectory, Project.Definition.Attr("JsonDir"), cls.Prototype, cls.Name + "." + cls.Prototype + ".json"); Directory.CreateDirectory(Path.GetDirectoryName(path)); var j = json is IDictionary<string,object>? json as IDictionary<string,object>: json.jsonifymap(); Refine(j, cls.Compiled,_opts:opts); File.WriteAllText(path,j.stringify(pretty:true)); }
/// <summary> /// /// </summary> /// <param name="model"></param> /// <param name="cls"></param> /// <returns></returns> public override AppStruct Setup(ApplicationModel model, IBSharpClass cls) { base.Setup(model, cls); Fields = new List <StructField>(); foreach (var field in cls.Compiled.Elements()) { Fields.Add(ResolveField(field)); } return(this); }
/// <summary> /// Создает типовую ошибку о дублировании имени класса /// </summary> /// <returns></returns> public static BSharpError DuplicateClassNames(IBSharpClass cls1, IBSharpClass cls2){ return new BSharpError{ Level = ErrorLevel.Error, Class = cls1, AltClass = cls2, Phase = BSharpCompilePhase.SourceIndexing, Type = BSharpErrorType.DuplicateClassNames, Message = "В коде обнаружено два класса с одинаковыми (полными) именами." }; }
/// <summary> /// </summary> /// <param name="targetclasses"></param> /// <returns></returns> protected override IEnumerable<Production> InternalGenerate(IBSharpClass[] targetclasses){ yield return new Production{ FileName = "Extensions/ResolveTagOptions.cs", GetContent = () => new ResolveTagOptionsWriter(Model).ToString() }; yield return new Production{ FileName = "Extensions/ResolveTagFacility.cs", GetContent = () => new ResolveTagFacilityWriter(Model).ToString() }; }
/// <summary> /// Резольвинг процедуры сохранения исходя из флагов в OutputAttributes /// Метод полностью реализует логику разделения реузльтатов компиляции /// по директориям исходя из установленных флагов в OutputAttributes /// </summary> /// <param name="bSharpClass"></param> /// <returns></returns> protected virtual BSharpBuilderWriteTarget GenerateTarget(IBSharpClass bSharpClass) { var outputAttributes = Project.OutputAttributes; var target = new BSharpBuilderWriteTarget { Directory = WorkingDirectory, Extension = Project.GetOutputExtension(), Filename = BSharpBuilderClassUtils.GetClassname(bSharpClass.FullName), MergeIfExists = false }; target.Entity.Add(GenerateBSharpClasset(bSharpClass.Compiled??bSharpClass.Source)); if (outputAttributes.HasFlag(BSharpBuilderOutputAttributes.TreeNamespace)) { target.Directory = Path.Combine( WorkingDirectory, BSharpBuilderClassUtils.GetRelativeDirByNamespace(bSharpClass.FullName) ); } if (outputAttributes.HasFlag(BSharpBuilderOutputAttributes.PlainNamespace)) { target.Directory = Path.Combine( WorkingDirectory, BSharpBuilderClassUtils.GetNamespace(bSharpClass.FullName) ); } if (outputAttributes.HasFlag(BSharpBuilderOutputAttributes.PrototypeAlign)){ var proto = bSharpClass.Prototype; if (!string.IsNullOrWhiteSpace(proto)){ target.Directory = Path.Combine( WorkingDirectory, proto ); } else{ target.Directory = WorkingDirectory; } } if (outputAttributes.HasFlag(BSharpBuilderOutputAttributes.UseFullName)) { target.Filename = bSharpClass.FullName; } if (outputAttributes.HasFlag(BSharpBuilderOutputAttributes.SingleFile)) { target.Filename = BSharpBuilderDefaults.SingleModeFilename; target.MergeIfExists = true; target.Directory = Path.Combine( WorkingDirectory, BSharpBuilderClassUtils.GetRelativeDirByNamespace(bSharpClass.FullName) ); } else { target.Entity = target.Entity.XPathSelectElement("//" + BSharpBuilderDefaults.BSharpClassContainerName); } return target; }
/// <summary> /// Создает типовую ошибку о дублировании имени класса /// </summary> /// <returns></returns> public static BSharpError DuplicateClassNames(IBSharpClass cls1, IBSharpClass cls2) { return(new BSharpError { Level = ErrorLevel.Error, Class = cls1, AltClass = cls2, Phase = BSharpCompilePhase.SourceIndexing, Type = BSharpErrorType.DuplicateClassNames, Message = "В коде обнаружено два класса с одинаковыми (полными) именами." }); }
/// <summary> /// Создает ошибку циклического импорта /// </summary> /// <returns></returns> public static BSharpError RecycleImport(IBSharpClass cls, string root, IBSharpImport i){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ImportResolution, Type = BSharpErrorType.RecycleImport, Data = i, ClassName = cls.FullName + " [ from root : " + root + " ]", Class = cls, Message = "Циклические ссылки означают ошибки в построении иерархии, при импорте такие ссылки игнорируются" }; }
/// <summary> /// Создает ошибку импорта класса-"сироты" /// </summary> /// <param name="cls"></param> /// <param name="i"></param> /// <returns></returns> public static BSharpError OrphanImport(IBSharpClass cls, IBSharpImport i){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ImportResolution, Type = BSharpErrorType.OrphanImport, Data = i, ClassName = cls.FullName, Class = cls, Message = "Импортируемый класс является сиротским и соответственно импорт реально не производится" }; }
/// <summary> /// Ошибка - класс "сирота" /// </summary> /// <param name="cls"></param> /// <returns></returns> public static BSharpError OrphanClass(IBSharpClass cls) { return(new BSharpError { Level = ErrorLevel.Error, Class = cls, Phase = BSharpCompilePhase.SourceIndexing, Type = BSharpErrorType.OrphanClass, Message = "В коде обнаружен участок, похожий на класс, но который нельзя связать ни с одной из имеющихся базовых классов или ключевым словом class" }); }
/// <summary> /// Создает ошибку импорта класса-"сироты" /// </summary> /// <param name="cls"></param> /// <param name="i"></param> /// <returns></returns> public static BSharpError NotResolvedImport(IBSharpClass cls, IBSharpImport i){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ImportResolution, Type = BSharpErrorType.NotResolvedImport, Data = i, ClassName = cls.FullName, Class = cls, Message = "В качестве источника для импорта указан несуществующий класс" }; }
/// <summary> /// Создает запись для класса /// </summary> /// <param name="cls"></param> /// <param name="context"></param> /// <returns></returns> protected override XElement CreateClassRecord(IBSharpClass cls, IBSharpContext context) { var result = GetIndexElement(cls); var src = new XElement(cls.Compiled) { Name = "Compiled" }; result.Add(src); return(result); }
/// <summary> /// Создает ошибку импорта класса-"сироты" /// </summary> /// <param name="cls"></param> /// <param name="i"></param> /// <returns></returns> public static BSharpError OrphanImport(IBSharpClass cls, IBSharpImport i) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ImportResolution, Type = BSharpErrorType.OrphanImport, Data = i, ClassName = cls.FullName, Class = cls, Message = "Импортируемый класс является сиротским и соответственно импорт реально не производится" }); }
/// <summary> /// Пустой инклуд /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError EmptyInclude(IBSharpClass cls, XElement e) { return(new BSharpError { Level = ErrorLevel.Warning, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.EmptyInclude, ClassName = cls.FullName, Class = cls, Xml = e, Message = "Инклуд, включаемый в режиме body не имеет контента, возможно ошибка в коде" }); }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError OrphanInclude(IBSharpClass cls, XElement e) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.OrphanInclude, ClassName = cls.FullName, Class = cls, Xml = e, Message = "Попытка включить класс-сироту" }); }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError PatchInvalidBehavior(IBSharpClass cls, XElement e) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.Patching, Type = BSharpErrorType.PatchError, ClassName = cls.FullName, Class = cls, Xml = e, Message = "В патче указан несуществующий тип поведения для новых элементов" }); }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError PatchUndefinedTarget(IBSharpClass cls, XElement e) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.Patching, Type = BSharpErrorType.PatchUndefinedTarget, ClassName = cls.FullName, Class = cls, Xml = e, Message = "В патче не указан селектор целевых классов" }); }
/// <summary> /// Формирует SQL-объект /// </summary> /// <param name="model"></param> /// <param name="cls"></param> /// <param name="bscls"></param> /// <param name="xml"></param> /// <returns></returns> public override SqlObject Setup(PersistentModel model, PersistentClass cls, IBSharpClass bscls, XElement xml) { base.Setup(model, cls, bscls, xml); TableName = cls.FullSqlName; Name = xml.Attr("code"); Schema = cls.Schema; Insert = xml.GetSmartValue("insert").ToBool(); Update = xml.GetSmartValue("update").ToBool(); Delete = xml.GetSmartValue("delete").ToBool(); Before = xml.GetSmartValue("before").ToBool(); return(this); }
/// <summary> /// Ошибка фейкового инклуда /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError FakeInclude(IBSharpClass cls, XElement e) { return(new BSharpError { Level = ErrorLevel.Warning, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.FakeInclude, ClassName = cls.FullName, Xml = e, Message = "В инклуде не указан код - это может быть как результат сознательного условного пустого инклуда или ошибка в коде" }); }
/// <summary> /// Настраивает отдельный хранимый класс из B# /// </summary> /// <param name="c"></param> public PersistentClass Setup(IBSharpClass c) { var xml = c.Compiled; ReadMainData(c, xml); ReadDataTypes(c, xml); ReadFields(c, xml); ReadAllocationInfo(c, xml); ReadInterfaces(c, xml); ResolveAccessMode(xml); return(this); }
public void WriteJson(IBSharpClass cls, object json = null, IList <string> opts = null) { json = json ?? new {}; var path = Path.Combine(Project.RootDirectory, Project.Definition.Attr("JsonDir"), cls.Prototype, cls.Name + "." + cls.Prototype + ".json"); Directory.CreateDirectory(Path.GetDirectoryName(path)); var j = json is IDictionary <string, object>?json as IDictionary <string, object> : json.jsonifymap(); Refine(j, cls.Compiled, _opts: opts); File.WriteAllText(path, j.stringify(pretty: true)); }
private Uri GetUri(IBSharpClass cls) { var url = "/" + cls.Name; if (!string.IsNullOrWhiteSpace(cls.Namespace)) { url = "/" + cls.Namespace.Replace(".", "/") + "/" + cls.Name; } var uri = new Uri(url, UriKind.Relative); return(uri); }
private void ReadMainData(IBSharpClass c, XElement xml) { TargetClass = c; Name = c.Name; Namespace = c.Namespace; Schema = xml.Attr("schema", "dbo").ToLowerInvariant(); Comment = xml.Attr("name"); Cloneable = xml.GetSmartValue("cloneable").ToBool(); ResolveAble = xml.GetSmartValue("resolve").ToBool(); CyclicId = xml.GetSmartValue("cyclicid").ToBool(); NoDefaultRows = xml.GetSmartValue("nodefaultrows").ToBool(); }
/// <summary> /// Создает ошибку циклического импорта /// </summary> /// <returns></returns> public static BSharpError RecycleImport(IBSharpClass cls, string root, IBSharpImport i) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ImportResolution, Type = BSharpErrorType.RecycleImport, Data = i, ClassName = cls.FullName + " [ from root : " + root + " ]", Class = cls, Message = "Циклические ссылки означают ошибки в построении иерархии, при импорте такие ссылки игнорируются" }); }
/// <summary> /// Создает ошибку импорта класса-"сироты" /// </summary> /// <param name="cls"></param> /// <param name="i"></param> /// <returns></returns> public static BSharpError NotResolvedImport(IBSharpClass cls, IBSharpImport i) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ImportResolution, Type = BSharpErrorType.NotResolvedImport, Data = i, ClassName = cls.FullName, Class = cls, Message = "В качестве источника для импорта указан несуществующий класс" }); }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError NotResolvedInclude(IBSharpClass cls, XElement e) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.NotResolvedInclude, ClassName = cls.FullName, Class = cls, Xml = e, Message = "Попытка включить несуществующий класс" }); }
/// <summary> /// Неоднозначная косвенная ссылка на класс /// </summary> /// <returns></returns> public static BSharpError AmbigousClassReference(IBSharpClass cls, XElement parent, string clsname) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.AmbigousClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Двойственная ссылка на класс - было найдено несколько кандидатов" }); }
/// <summary> /// Ошибка неразрешенной ссылки на класс /// </summary> /// <param name="cls"></param> /// <param name="parent"></param> /// <param name="clsname"></param> /// <returns></returns> public static BSharpError NotResolvedClassReference(IBSharpClass cls, XElement parent, string clsname) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.NotResolvedClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Не найден класс, на который указывает ссылка" }); }
/// <summary> /// Неоднозначная косвенная ссылка на класс /// </summary> /// <returns></returns> public static BSharpError AbstractClassReference(IBSharpClass cls, XElement parent, string clsname) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.AbstractClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Ссылка на абстрактный класс" }); }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <returns></returns> public static BSharpError PatchError(IBSharpClass cls, IBSharpClass altcls, string diff, Exception error) { return(new BSharpError { Level = ErrorLevel.Error, Phase = BSharpCompilePhase.Patching, Type = BSharpErrorType.PatchError, ClassName = cls.FullName, Class = cls, AltClass = altcls, Message = diff, Error = error }); }
/// <summary> /// Подсказка косвенной ссылки на класс /// </summary> /// <returns></returns> public static BSharpError NotDirectClassReference(IBSharpClass cls, XElement parent, string clsname) { return(new BSharpError { Level = ErrorLevel.Warning, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.NotDirectClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Ссылка на класс разрешена косвенно по имени, а не по стеку пространств имен" }); }
/// <summary> /// </summary> /// <param name="targetclasses"></param> /// <returns></returns> protected override IEnumerable<Production> InternalGenerate(IBSharpClass[] targetclasses) { foreach (var cls in Model.Classes.Values.Where(_=>!_.NoSql).ToArray()) { yield return new Production { FileName = "Adapters/" + cls.Name + "DataAdapter.cs", GetContent = () => new PokoAdapterWriter(cls).ToString() }; yield return new Production { FileName = "ObjectCaches/" + cls.Name + "DataCache.cs", GetContent = () => new PokoObjectCacheWriter(cls).ToString() }; } }
/// <summary> /// </summary> /// <param name="targetclasses"></param> /// <returns></returns> protected override IEnumerable<Production> InternalGenerate(IBSharpClass[] targetclasses){ foreach (var cls in Tables) { var fields = cls.Fields.Values.Where(_ => _.IsHash).ToArray(); if (fields.Length == 0) continue; yield return new Production{ FileName = "SimpleComparers/" + cls.Name + "Comparer.cs", GetContent = () => new SimpleComparerClassWriter(cls).ToString() }; } //return from cls in Tables //select }
/// <summary> /// </summary> /// <param name="model"></param> /// <param name="cls"></param> /// <param name="bscls"></param> /// <param name="xml"></param> public override SqlObject Setup(PersistentModel model, PersistentClass cls, IBSharpClass bscls, XElement xml){ base.Setup(model, cls, bscls, xml); if (null != xml){ Start = xml.Attr("start", "10").ToInt(); Step = xml.Attr("step", "10").ToInt(); } Name = cls.Name + "_SEQ"; Schema = cls.Schema; IsCyclic = cls.CyclicId; if (null != cls.PrimaryKey){ DataType = cls.PrimaryKey.DataType; } else{ DataType = cls.DataTypeMap["int"]; } return this; }
/// <summary> /// Ошибка - класс "сирота" /// </summary> /// <param name="cls"></param> /// <returns></returns> public static BSharpError OrphanClass(IBSharpClass cls){ return new BSharpError{ Level = ErrorLevel.Error, Class = cls, Phase = BSharpCompilePhase.SourceIndexing, Type = BSharpErrorType.OrphanClass, Message = "В коде обнаружен участок, похожий на класс, но который нельзя связать ни с одной из имеющихся базовых классов или ключевым словом class" }; }
/// <summary> /// Пустой инклуд /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError EmptyInclude(IBSharpClass cls, XElement e){ return new BSharpError{ Level = ErrorLevel.Warning, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.EmptyInclude, ClassName = cls.FullName, Class = cls, Xml = e, Message = "Инклуд, включаемый в режиме body не имеет контента, возможно ошибка в коде" }; }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError OrphanInclude(IBSharpClass cls, XElement e){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.OrphanInclude, ClassName = cls.FullName, Class = cls, Xml = e, Message = "Попытка включить класс-сироту" }; }
private void SetupDefaultValue(IBSharpClass c, XElement e){ DefaultSqlValue = DefaultValue.Create(this, e.Attr("default"), e); DefaultObjectValue = DefaultValue.Create(this, e.Attr("csharp-default"), e); }
/// <summary> /// Неоднозначная косвенная ссылка на класс /// </summary> /// <returns></returns> public static BSharpError AbstractClassReference(IBSharpClass cls, XElement parent, string clsname){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.AbstractClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Ссылка на абстрактный класс" }; }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError NotResolvedInclude(IBSharpClass cls, XElement e){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.NotResolvedInclude, ClassName = cls.FullName, Class = cls, Xml = e, Message = "Попытка включить несуществующий класс" }; }
private void SetupReference(IBSharpClass c, XElement e){ IsReference = true; IsAutoLoadByDefault = e.GetSmartValue("auto").ToBool(); IsLazyLoadByDefault = e.GetSmartValue("lazy").ToBool(); IsReverese = e.GetSmartValue("reverse").ToBool(); //проверяем, что реверс указан не как флаг, а как имя коллекции if (IsReverese && 0 == e.GetSmartValue("reverse").ToInt()){ CustomReverseName = e.GetSmartValue("reverse"); } IsAutoLoadReverseByDefault = e.GetSmartValue("reverse-auto").ToBool(); IsLazyLoadReverseByDefault = e.GetSmartValue("reverse-lazy").ToBool(); IsReverseCloneByDefault = e.GetSmartValue("reverse-clone").ToBool(); string refto = ""; if (ImplicitRef){ refto = e.Name.LocalName + ".PrimaryKey"; } else{ refto = e.Attr("to", Name + ".PrimaryKey"); if (!refto.Contains(".")) { refto += ".PrimaryKey"; } } string[] refparts = refto.Split('.'); ReferenceTable = refparts[refparts.Length - 2].ToLowerInvariant(); ReferenceField = refparts[refparts.Length - 1].ToLowerInvariant(); if (refparts.Length > 2){ ReferenceSchema = refparts[refparts.Length - 3].ToLowerInvariant(); } DataType = Table.DataTypeMap["int"]; if (ReferenceField.ToLowerInvariant() == "code"){ DataType = Table.DataTypeMap["string"]; } if (ResolvePriority==55555) { ResolvePriority = 99999; } }
private void SetupUsualField(IBSharpClass c, XElement e){ DataType = Table.DataTypeMap[e.Name.LocalName]; IsPrimaryKey = e.GetSmartValue("primarykey").ToBool(); if (!IsPrimaryKey) { IsUnique = e.GetSmartValue("unique").ToBool(); } else { IsUnique = true; } IsAutoIncrement = e.GetSmartValue("identity").ToBool(); string csharptype = e.GetSmartValue("csharp-type"); if (!string.IsNullOrWhiteSpace(csharptype)){ DataType realtype = DataType.Copy(); realtype.CSharpDataType = csharptype; DataType = realtype; } }
private void SetupCommon(IBSharpClass c, XElement e){ Name = e.Attr("code"); Comment = e.Attr("name"); IsHash = e.Attr("hash").ToBool(); Idx = e.Attr("idx").ToInt(); if (0 == Idx) Idx = 99999; Resolve = e.GetSmartValue("resolve").ToBool(); ResolvePriority = e.GetSmartValue("resolve").ToInt(); if (1>=ResolvePriority){ ResolvePriority = 55555; } NoSql = e.GetSmartValue("nosql").ToBool(); ComputeAs = e.GetSmartValue("as").ToString(); NoCode = e.GetSmartValue("nocode").ToBool(); IsCloneByDefault = e.GetSmartValue("clone").ToBool(); //Name = PersistentClass.EscapeSqlName(Name); }
/// <summary> /// Подсказка косвенной ссылки на класс /// </summary> /// <returns></returns> public static BSharpError NotDirectClassReference(IBSharpClass cls, XElement parent, string clsname){ return new BSharpError{ Level = ErrorLevel.Warning, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.NotDirectClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Ссылка на класс разрешена косвенно по имени, а не по стеку пространств имен" }; }
/// <summary> /// Неоднозначная косвенная ссылка на класс /// </summary> /// <returns></returns> public static BSharpError AmbigousClassReference(IBSharpClass cls, XElement parent, string clsname){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.AmbigousClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Двойственная ссылка на класс - было найдено несколько кандидатов" }; }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError PatchUndefinedTarget(IBSharpClass cls, XElement e){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.Patching, Type = BSharpErrorType.PatchUndefinedTarget, ClassName = cls.FullName, Class = cls, Xml = e, Message = "В патче не указан селектор целевых классов" }; }
/// <summary> /// Ошибка неразрешенной ссылки на класс /// </summary> /// <param name="cls"></param> /// <param name="parent"></param> /// <param name="clsname"></param> /// <returns></returns> public static BSharpError NotResolvedClassReference(IBSharpClass cls, XElement parent, string clsname){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.ReferenceResolution, Type = BSharpErrorType.NotResolvedClassReference, ClassName = cls.FullName, Xml = parent, Data = clsname, Class = cls, Message = "Не найден класс, на который указывает ссылка" }; }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <returns></returns> public static BSharpError PatchError(IBSharpClass cls, IBSharpClass altcls, string diff, Exception error){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.Patching, Type = BSharpErrorType.PatchError, ClassName = cls.FullName, Class = cls, AltClass = altcls, Message = diff, Error = error }; }
/// <summary> /// Ошибка фейкового инклуда /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError FakeInclude(IBSharpClass cls, XElement e){ return new BSharpError{ Level = ErrorLevel.Warning, Phase = BSharpCompilePhase.IncludeProcessing, Type = BSharpErrorType.FakeInclude, ClassName = cls.FullName, Xml = e, Message = "В инклуде не указан код - это может быть как результат сознательного условного пустого инклуда или ошибка в коде" }; }
/// <summary> /// Ошибка включения несуществующего класса /// </summary> /// <param name="cls"></param> /// <param name="e"></param> /// <returns></returns> public static BSharpError PatchInvalidBehavior(IBSharpClass cls, XElement e){ return new BSharpError{ Level = ErrorLevel.Error, Phase = BSharpCompilePhase.Patching, Type = BSharpErrorType.PatchError, ClassName = cls.FullName, Class = cls, Xml = e, Message = "В патче указан несуществующий тип поведения для новых элементов" }; }