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 = "В патче указан несуществующий тип поведения для новых элементов"
};
}
