public WordAsm(AssemblyBase srcAsm) : base(srcAsm)
{
var store = Session.Instance().Store;
this.srcAsm = srcAsm;
this.Order = srcAsm.Order;
this.lx_id = Convert.ToInt64(srcAsm.GetValue("lx_id"));
var asmlex = store.GetAssembly(lx_id);
this.id_partofspeech = Convert.ToInt32(asmlex.GetValue("GrenPart"));
this.EntryName = (string)asmlex.GetValue("Lemma");
this.rcind = Convert.ToInt32(srcAsm.GetValue("rcind"));
//wasm.xPart = wmap.xPart;
this.RealWord = (string)srcAsm.GetValue("RealWord");
var gramIDs = (List <long>)srcAsm.GetValue("Grammems");
if (gramIDs != null)
{
foreach (var ID in gramIDs)
{
var asm = store.GetAssembly(ID);
var gram = new GrammemAsm(asm);
grammems.Add(gram);
}
}
}
public override void Compile()
{
var FullName = this.FullName;
HashSet <string> names = new HashSet <string>();
foreach (var item in Items)
{
if (item.Name.Length == 0)
{
throw new Exception($"{FullName} 常量字段名不能为空");
}
if (!names.Add(item.Name))
{
throw new Exception($"{FullName} 字段名:{item.Name} 重复");
}
if ((item.CType = AssemblyBase.CreateType(Namespace, item.Type)) == null)
{
throw new Exception($"{FullName} type:{item.Type} 类型不存在");
}
if (!item.CType.TryParseFrom(item.Value))
{
throw new Exception($"{FullName} value:{item.Value} 不是合法的 type:{item.Type} 类型值");
}
}
}
public SentenceAsm(AssemblyBase srcAsm) : base(srcAsm)
{
this.srcAsm = srcAsm;
var store = Session.Instance().Store;
var wordIDs = (List <long>)srcAsm.GetValue("Words");
int i = 0;
if (wordIDs != null)
{
foreach (var ID in wordIDs)
{
var asm = store.GetAssembly(ID, false);
var word = new WordAsm(asm);
word.Order = i++;
words.Add((int)word.Order, word);
}
}
var syntIDs = (List <long>)srcAsm.GetValue("SyntNodes");
if (syntIDs != null)
{
foreach (var ID in syntIDs)
{
var asm = store.GetAssembly(ID, false);
var syntNode = new SyntNodeAsm(asm);
treeList.Add(syntNode);
}
}
this.sentence = RestorePhrase();
this.IsActual = true;
}
public void SerializationTest()
{
List <NamespaceBase> list = new List <NamespaceBase>()
{
new NamespaceBase()
{
name = "n1"
},
new NamespaceBase()
{
name = "n2"
}
};
AssemblyBase originalObject = new AssemblyBase()
{
name = "test",
namespaces = list
};
XMLSerializer serializer = new XMLSerializer();
string path = "SerializationTestFile.xml";
serializer.Serialize(path, originalObject);
AssemblyBase deserializedObject = serializer.Deserialize(path);
Assert.AreEqual(originalObject.name, deserializedObject.name);
Assert.AreEqual(originalObject.namespaces.ToList()[0].name, deserializedObject.namespaces.ToList()[0].name);
Assert.AreEqual(originalObject.namespaces.ToList()[1].name, deserializedObject.namespaces.ToList()[1].name);
if (File.Exists(path))
{
File.Delete(path);
}
}
public override AssemblyBase CreateAssembly(BlockType type, BlockAddress ParentContID = -1)
{
var id = DBserver.CreateBlock(type.BlockTypeID, ParentContID, 0);
var asm = new AssemblyBase(id, type);
return(asm);
}
public SyntNodeAsm(AssemblyBase srcAsm) : base(srcAsm)
{
this.srcAsm = srcAsm;
c_id = Convert.ToInt64(srcAsm.GetValue("c_id"));
grenLink = Convert.ToInt64(srcAsm.GetValue("GrenLink"));
level = Convert.ToInt64(srcAsm.GetValue("level"));
pс_id = Convert.ToInt64(srcAsm.GetValue("pс_id"));
}
/// <summary>
/// Создание сборки по образцу / шаблону.
/// При создании новой сборки копируется структура (дочерние сборки) из образца / шаблона.
/// </summary>
/// <param name="templAsm">сборка - образец или шаблон</param>
/// <param name="mode">признак, определяющий, сохранять ссылку на шаблон\образец или нет</param>
/// <returns>сборка</returns>
public AssemblyBase CreateAssembly(AssemblyBase templAsm, FOLLOWMODE mode = FOLLOWMODE.Forget)
{
var id = DBserver.CreateBlock(templAsm.BlockType.BlockTypeID, -1, 0);
var asm = new AssemblyBase(templAsm, id, mode);
CreateChildrenRequrs(asm.Children);
return(asm);
}
public override void Save()
{
var store = Session.Instance().Store;
srcAsm = store.GetLexema(grenPart, lemma, true);
this.BlockID = srcAsm.BlockID;
this.ParentID = srcAsm.ParentID;
this.FactID = srcAsm.FactID;
}
public AssemblyBase CreateDocument(string name, BlockAddress ParentID)
{
var documentType = Session.Instance().GetBlockTypeByNameKey(Session.documentTypeName);
var asm = new AssemblyBase(documentType);
asm.ParentID = ParentID;
asm.SetValue("Name", name);
asm.Save();
return(asm);
}
public DocumentAsm(AssemblyBase srcAsm) : base(srcAsm)
{
this.srcAsm = srcAsm;
var attrval = (List <BlockAddress>)srcAsm.GetValue("ParagraphLinks");
if (attrval == null)
{
return;
}
ParagraphLinks.AddRange(attrval);
}
public override AssemblyBase GetAssembly(long Addr, bool FillChildren = true)
{
var block = DBserver.GetBlock(Addr);
var asm = new AssemblyBase(block);
if (FillChildren)
{
this.AsmFillChildren(asm);
}
return(asm);
}
/// <summary>
/// Заполнение узла дочерними узлами
/// </summary>
private void PopulateChildrenTree(AssemblyBase asm, AsmNode nodeToAddTo)
{
foreach (var chld in asm.Children)
{
if (FindNode(chld.BlockID, nodeToAddTo) != null)
{
continue;
}
var aNode = new AsmNode(chld, chld.Name);
nodeToAddTo.Nodes.Add(aNode);
}
}
protected void With_AssemblyFromFilePath()
{
Reflector reflector = new Reflector();
if (string.IsNullOrEmpty(FilePath))
{
throw new System.ArgumentNullException();
}
Assembly assembly = Assembly.LoadFrom(FilePath);
Root = reflector.LoadAssembly(FilePath);
}
public void When_SerializeDeserialize(AssemblyBase model)
{
try
{
Task.Run(() => _context.Serialize(model, ResultPath)).Wait();
_when = Task.Run(() => _context.Deserialize(ResultPath));
_when.Wait();
}
catch (AggregateException)
{
}
}
/// <summary>
/// Получение дочерних сборок множества родительских сборок.
/// Выбираются только прямые наследники (без ссылок)
/// </summary>
/// <param name="list_ids">список ID родительских сборок</param>
/// <returns>DataTable</returns>
public List <AssemblyBase> GetChildren(List <string> list_ids)
{
var listBlocks = DBserver.GetChildren(list_ids);
var listAsm = new List <AssemblyBase>();
foreach (var block in listBlocks)
{
var asm = new AssemblyBase(block);
listAsm.Add(asm);
}
return(listAsm);
}
public override List <AssemblyBase> SearchAsms(long blockType, Dictionary <string, object> args)
{
var blocklist = DBserver.SearchBlocks(blockType, args);
var result = new List <AssemblyBase>();
foreach (var block in blocklist)
{
var asm = new AssemblyBase(block);
result.Add(asm);
}
return(result);
}
/// <summary>
/// Заполнение сборки данными о детях.
/// </summary>
/// <param name="parentAsm">сборка</param>
/// <returns></returns>
public void AsmFillChildren(AssemblyBase parentAsm)
{
var list_ids = new List <string> {
parentAsm.BlockID.ToString()
};
var listCh = this.GetChildren(list_ids);
foreach (var child in listCh)
{
parentAsm.AddChild(child);
}
}
protected void ResolveExternalType()
{
if (!string.IsNullOrEmpty(_externalTypeName))
{
if (AssemblyBase.TryGetExternalType(_externalTypeName, out var type))
{
this.ExternalType = type;
}
else
{
throw new Exception($"enum:'{FullName}' 对应的 externaltype:{_externalTypeName} 不存在");
}
}
}
/// <summary>
/// Заполнение внутреннего хранилища.
/// </summary>
public void Refresh()
{
containers.Clear();
var MainStore = new AssemblyBase(Session.MainStoreID, Session.Instance().GetBlockTypeByNameKey(Session.containerTypeName));
MainStore.IsMainDataContainer = true;
store.AsmFillChildren(MainStore);
containers.Add(MainStore);
var DictsStore = new AssemblyBase(Session.DictsStoreID, Session.Instance().GetBlockTypeByNameKey(Session.containerTypeName));
DictsStore.IsDictsStore = true;
store.AsmFillChildren(DictsStore);
containers.Add(DictsStore);
}
public override void PreCompile()
{
if (!string.IsNullOrEmpty(Parent))
{
if ((ParentDefType = (DefBeanBase)AssemblyBase.GetDefType(Namespace, Parent)) == null)
{
throw new Exception($"bean:'{FullName}' parent:'{Parent}' not exist");
}
if (ParentDefType.Children == null)
{
ParentDefType.Children = new List <DefBeanBase>();
}
ParentDefType.Children.Add(this);
}
CollectHierarchyFields(HierarchyFields);
}
public ParagraphAsm(AssemblyBase srcAsm) : base(srcAsm)
{
IsDirty = false;
this.srcAsm = srcAsm;
var store = Session.Instance().Store;
var sentIDs = (List <long>)srcAsm.GetValue("Phrases");
if (sentIDs != null)
{
foreach (var sentID in sentIDs)
{
var asm = store.GetAssembly(sentID, false);
var sent = new SentenceAsm(asm);
innerPara.Add(sent);
}
}
}
public virtual void Compile()
{
if (Id < 0 || Id > 256)
{
throw new Exception($"type:'{HostType.FullName}' field:'{Name}' id:{Id} 超出范围");
}
if (!IgnoreNameValidation && !TypeUtil.IsValidName(Name))
{
throw new Exception($"type:'{HostType.FullName}' field name:'{Name}' is reserved");
}
try
{
CType = AssemblyBase.CreateType(HostType.Namespace, Type);
}
catch (Exception e)
{
throw new Exception($"type:'{HostType.FullName}' field:'{Name}' type:'{Type}' is invalid", e);
}
//if (IsNullable && (CType.IsCollection || (CType is TBean)))
//{
// throw new Exception($"type:{HostType.FullName} field:{Name} type:{Type} is collection or bean. not support nullable");
//}
switch (CType)
{
case TArray t:
{
if (t.ElementType is TBean e && !e.IsDynamic && e.Bean.HierarchyFields.Count == 0)
{
throw new Exception($"container element type:'{e.Bean.FullName}' can't be empty bean");
}
break;
}
case TList t:
{
if (t.ElementType is TBean e && !e.IsDynamic && e.Bean.HierarchyFields.Count == 0)
{
throw new Exception($"container element type:'{e.Bean.FullName}' can't be empty bean");
}
break;
}
}
}
public AsmNode(AssemblyBase _assembly, string Name = null) : base(_assembly == null ? Name ?? defaultName : _assembly.Name)
{
assembly = _assembly;
switch (assembly.BlockType.NameKey)
{
case "DataContainer":
NodeType = clNodeType.clnContainer;
break;
case "Document":
NodeType = clNodeType.clnDocument;
break;
case "Paragraph":
NodeType = clNodeType.clnParagraph;
break;
}
}
public override void PreCompile()
{
if (!string.IsNullOrEmpty(Parent))
{
if ((ParentDefType = (DefBean)AssemblyBase.GetDefType(Namespace, Parent)) == null)
{
throw new Exception($"bean:'{FullName}' parent:'{Parent}' not exist");
}
if (ParentDefType.Children == null)
{
ParentDefType.Children = new List <DefBeanBase>();
}
ParentDefType.Children.Add(this);
}
CollectHierarchyFields(HierarchyFields);
this.ExportFields = this.Fields.Select(f => (DefField)f).Where(f => f.NeedExport).ToList();
this.HierarchyExportFields = this.HierarchyFields.Select(f => (DefField)f).Where(f => f.NeedExport).ToList();
}
public FormParaEdit(AsmNode theNode, treeOper tOper)
{
InitializeComponent();
this.theNode = theNode;
this.typeOper = tOper;
AssemblyBase asm = null;
switch (tOper)
{
case (treeOper.toEdit):
asm = theNode.Assembly;
break;
case (treeOper.toAdd):
asm = store.CreateParagraph(theNode.Assembly.BlockID);
break;
}
this.paraAsm = new ParagraphAsm(asm);
}
private void LoadDLL()
{
try {
tracer.GetImport().Log(TraceLevel.Info, "load button clicked");
if (PathVariable.Substring(PathVariable.Length - 4) == ".dll")
{
tracer.GetImport().Log(TraceLevel.Info, "selected DLL file");
assemblyMetadataView = new AssemblyMetadataView(PathVariable);
TreeViewLoaded();
}
else if (PathVariable.Substring(PathVariable.Length - 4) == ".xml")
{
tracer.GetImport().Log(TraceLevel.Info, "selected XML file");
AssemblyBase baseAssembly = serializer.GetImport().Deserialize(PathVariable);
assemblyMetadataView = new AssemblyMetadataView(baseAssembly);
TreeViewLoaded();
}
}
catch (System.SystemException e)
{
tracer.GetImport().Log(TraceLevel.Error, "tried to load without selecting a file");
}
}
public void SerializationTest()
{
IFileSelector selector = new Selector();
List <NamespaceBase> namespaceList = new List <NamespaceBase>()
{
new NamespaceBase()
{
Name = "name1"
},
new NamespaceBase()
{
Name = "name2"
}
};
AssemblyBase assemblyObject = new AssemblyBase()
{
Name = "test",
Namespaces = namespaceList
};
XMLSerializer serializer = new XMLSerializer();
string path = "SerializationXMLTest.xml";
serializer.Serialize(selector, assemblyObject);
AssemblyBase deserializedObject = serializer.Deserialize(selector);
Assert.AreEqual(assemblyObject.Name, deserializedObject.Name);
Assert.AreEqual(assemblyObject.Namespaces.ToList()[0].Name, deserializedObject.Namespaces.ToList()[0].Name);
Assert.AreEqual(assemblyObject.Namespaces.ToList()[1].Name, deserializedObject.Namespaces.ToList()[1].Name);
if (File.Exists(path))
{
File.Delete(path);
}
}
public override AssemblyBase GetLexema(long grenPart, string lemma, bool CreateIfNotExists = false)
{
var lexType = Session.Instance().GetBlockTypeByNameKey(Session.lexTypeName);
var args = new Dictionary <string, object>();
args.Add("GrenPart", grenPart);
args.Add("Lemma", lemma.ToLower());
var asm = this.SearchAsms(lexType.BlockTypeID, args).FirstOrDefault();
if (asm == null && CreateIfNotExists)
{
asm = new AssemblyBase(lexType);
asm.ParentID = Session.DictLemmsID;
}
if (asm != null)
{
asm.SetValue("Name", lemma);
asm.SetValue("GrenPart", grenPart);
asm.SetValue("Lemma", lemma);
asm.Save();
}
return(asm);
}
public void LoadAssemblyFromStorage()
{
AssemblyBase deserializedAssemblyReader = Serializer.Deserialize();
AssemblyModel = new AssemblyModel(deserializedAssemblyReader);
}
private void Result_Should_BeEquivalent(AssemblyBase root)
{
_when.Result.Name.Should().BeEquivalentTo(root.Name);
_when.Result.Namespaces.Should().HaveSameCount(root.Namespaces);
_when.Result.Namespaces.Should().OnlyContain(p => root.Namespaces.Count(n => n.Name == p.Name) == 1);
}
