void MakeWrittable() { if (_writting) { return; } if (_preapprovedWritting) { _writting = true; _preapprovedWritting = false; return; } if (_readOnly) { throw new BTDBTransactionRetryException("Cannot write from readOnly transaction"); } var oldArtRoot = ArtRoot; ArtRoot = _keyValueDB.MakeWrittableTransaction(this, oldArtRoot); _cursor.SetNewRoot(ArtRoot); if (_cursor2 != null) { _cursor2.SetNewRoot(ArtRoot); } ArtRoot.DescriptionForLeaks = _descriptionForLeaks; _writting = true; }
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value) { IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; if (svc != null) { IRootNode rootNode = context.Instance as IRootNode; if (rootNode != null) { IBaseNode variables = rootNode.Tree.RootNode.GetNode(eNodeType.VariableDefinitions); string domainTemplate = rootNode.DomainTemplate; using (BulkImportForm frm = new BulkImportForm(variables, ucProperties.App, domainTemplate, eImportMode.Template)) { if (svc.ShowDialog(frm) == DialogResult.OK) { if (frm.ModelFile != "") { rootNode.Tree.ImportVariables(frm.ImportVariables); } (rootNode as UI_RootNode).Propegate = false; value = frm.ModelFile; } } } } return(value); }
internal void DereferenceRoot(IRootNode currentArtRoot) { if (currentArtRoot.Dereference()) { _waitingToDispose.Add(currentArtRoot); } }
public void Commit() { if (ArtRoot == null) { throw new BTDBException("Transaction already commited or disposed"); } InvalidateCurrentKey(); var currentArtRoot = ArtRoot; ArtRoot = null; if (_preapprovedWritting) { _preapprovedWritting = false; _keyValueDB.RevertWrittingTransaction(currentArtRoot); } else if (_writting) { _keyValueDB.CommitWrittingTransaction(currentArtRoot); _writting = false; } else { _keyValueDB.DereferenceRoot(currentArtRoot); } }
public string MakeDiagram(IRootNode rootNode) { if (rootNode == null) { throw new ArgumentNullException($"{nameof(rootNode)} is null."); } var sb = new StringBuilder(); _stringMaxLength = GetMaxLengthOfString(rootNode); sb.AppendLine(MakeDivider()); sb.AppendLine(MakeHeader(rootNode.Name)); sb.AppendLine(MakeDivider()); if (rootNode.HasDataNodes) { sb.AppendLine(MakeAttributeBlock(rootNode.DataNodes)); } sb.AppendLine(MakeDivider()); if (rootNode.HasBehaviorNodes) { sb.AppendLine(MakeBehaviorBlock(rootNode.BehaviorNodes)); } sb.AppendLine(MakeDivider()); return(sb.ToString()); }
public void Run(IRootNode rootNode, string moduleName, Stream output) { var assemblyName = new AssemblyName(moduleName); var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); var moduleBuilder = assemblyBuilder.DefineDynamicModule(moduleName); var typeBuilder = moduleBuilder.DefineType("Program", TypeAttributes.Class | TypeAttributes.Public); var methodBuilder = typeBuilder.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static); var ilGenerator = methodBuilder.GetILGenerator(); // var i : number = 1; var i = ilGenerator.DeclareLocal(typeof(float)); ilGenerator.Emit(OpCodes.Ldc_R4, 1.0); ilGenerator.Emit(OpCodes.Stloc, i); // var j : number = i + 2; var j = ilGenerator.DeclareLocal(typeof(float)); ilGenerator.Emit(OpCodes.Ldloc, i); ilGenerator.Emit(OpCodes.Ldc_R4, 2.0); ilGenerator.Emit(OpCodes.Add); ilGenerator.Emit(OpCodes.Stloc, j); }
/// <summary> /// 文字列の最大文字数を取得する /// </summary> /// <param name="nodes">ノード</param> /// <returns></returns> //private int GetMaxLengthOfString(IReadOnlyList<INode> nodes) // => nodes.Max(node => node.FullName.Length); private int GetMaxLengthOfString(IRootNode rootNode) { var classFullNameLength = rootNode.FullName.Length; var dataNodeFullNameLength = rootNode.HasDataNodes ? rootNode.DataNodes.Max(x => x.FullName.Length) : 0; var behaviorNodeFullNameLength = rootNode.HasBehaviorNodes ? rootNode.BehaviorNodes.Max(x => x.FullName.Length) : 0; return(new[] { classFullNameLength, dataNodeFullNameLength, behaviorNodeFullNameLength }.Max()); }
void NewWrittingTransactionUnsafe(TaskCompletionSource <IKeyValueDBTransaction> tcs) { FreeWaitingToDispose(); var newTransactionRoot = LastCommited; _lastCommited = newTransactionRoot.Snapshot(); _writingTransaction = new ArtInMemoryKeyValueDBTransaction(this, newTransactionRoot, true, false); tcs.TrySetResult(_writingTransaction); }
public BinaryTree(IRootNode rootNode) { if (rootNode == null) { throw new System.ArgumentNullException(nameof(rootNode)); } RootNode = rootNode; }
internal void RevertWritingTransaction(IRootNode currentArtRoot) { lock (_writeLock) { currentArtRoot.Dispose(); _writingTransaction = null; TryDequeWaiterForWritingTransaction(); } }
public void Run(IRootNode rootNode, string moduleName, Stream output) { var builtInTypes = new List <(string type, string MetadataName)>() { ("any", "System.Object"), ("number", "System.Single"), ("string", "System.String"), ("void", "System.Void") }; var assemblyName = new AssemblyNameDefinition(moduleName, new Version(1, 0)); _assemblyDef = AssemblyDefinition.CreateAssembly(assemblyName, moduleName, ModuleKind.Console); _knownTypes = new Dictionary <string, TypeReference>(); var assembly = AssemblyDefinition.ReadAssembly(MsCorLib); _assemblies.Add(assembly); foreach (var(typeSymbol, metadataName) in builtInTypes) { var typeDefinition = ResolveTypeDefinition(metadataName); var typeReference = _assemblyDef.MainModule.ImportReference(typeDefinition); _knownTypes.Add(typeSymbol, typeReference); } var objectType = _knownTypes["any"]; var typeDef = new TypeDefinition("", "Program", TypeAttributes.Abstract | TypeAttributes.Sealed, objectType); _assemblyDef.MainModule.Types.Add(typeDef); var consoleTypeDef = ResolveTypeDefinition("System.Console"); _assemblyDef.MainModule.ImportReference(consoleTypeDef); var voidType = _knownTypes["void"]; _mainMethod = new MethodDefinition("Main", MethodAttributes.Static | MethodAttributes.Private, voidType); typeDef.Methods.Add(_mainMethod); _assemblyDef.EntryPoint = _mainMethod; _printMethods.Add("string", ResolveMethod("System.Console", "Write", new[] { "System.String" })); _printMethods.Add("number", ResolveMethod("System.Console", "Write", new[] { "System.Single" })); _writeLineMethod = ResolveMethod("System.Console", "WriteLine", new string[0]); foreach (var stmt in rootNode.Statements) { TraverseTree(stmt, _mainMethod.Body); } _mainMethod.Body.GetILProcessor().Emit(OpCodes.Ret); _assemblyDef.Write(output); }
public void SetNewRoot(IRootNode artRoot) { var newRoot = (RootNode12)artRoot; if (newRoot._impl != _rootNode._impl) { throw new ArgumentException("SetNewRoot allows only same db instance"); } _rootNode = (RootNode12)artRoot; }
public void SetNewRoot(IRootNode artRoot) { var newRoot = (RootNode)artRoot; if (newRoot._root != _rootNode._root) { throw new ArgumentException("SetNewRoot allows only upgrades to writtable identical root"); } _rootNode = (RootNode)artRoot; }
public BTreeKeyValueDBTransaction(BTreeKeyValueDB keyValueDB, IRootNode root, bool writing, bool readOnly) { _preapprovedWriting = writing; _readOnly = readOnly; _keyValueDB = keyValueDB; _keyIndex = -1; _cursor = root.CreateCursor(); _cursor2 = null; BTreeRoot = root; _cursorMovedCounter = 0; }
public ArtInMemoryKeyValueDBTransaction(ArtInMemoryKeyValueDB keyValueDB, IRootNode artRoot, bool writting, bool readOnly) { _preapprovedWritting = writting; _readOnly = readOnly; _keyValueDB = keyValueDB; _prefix = BitArrayManipulation.EmptyByteArray; _prefixKeyStart = 0; _prefixKeyCount = -1; _keyIndex = -1; _cursor = artRoot.CreateCursor(); _cursor2 = null; ArtRoot = artRoot; }
public BTreeKeyValueDBTransaction(BTreeKeyValueDB keyValueDB, IRootNode artRoot, bool writing, bool readOnly) { _preapprovedWriting = writing; _readOnly = readOnly; _keyValueDB = keyValueDB; _prefix = Array.Empty <byte>(); _prefixKeyStart = 0; _prefixKeyCount = -1; _keyIndex = -1; _cursor = artRoot.CreateCursor(); _cursor2 = null; BTreeRoot = artRoot; }
internal void CommitWrittingTransaction(IRootNode artRoot) { lock (_writeLock) { _writingTransaction = null; if (_lastCommited.Dereference()) { _lastCommited.Dispose(); } _lastCommited = artRoot; TryDequeWaiterForWrittingTransaction(); } }
public void Check(IRootNode rootNode) { foreach (var stmtNode in rootNode.Statements) { if (stmtNode.AstNodeType == AstNodeTypes.VarStatement) { Check(stmtNode.AsVarStatement()); } else if (stmtNode.AstNodeType == AstNodeTypes.PrintStatement) { Check(stmtNode.AsPrintStatement()); } } }
internal void RevertWrittingTransaction(IRootNode currentArtRoot) { lock (_writeLock) { currentArtRoot.RevertTo(_lastCommited); if (_lastCommited.Dereference()) { _lastCommited.Dispose(); } _lastCommited = currentArtRoot; _writingTransaction = null; TryDequeWaiterForWrittingTransaction(); } }
bool IDecisionTree.LoadDomainTemplate(IRootNode rootNode) { IPersistence persistence = Persistence.Clone(rootNode.DomainTemplate); if (persistence != null) { IDecisionTree subTree = IDecisionTreeInterface.Clone(); IBaseNode variables = subTree.LoadVariables(persistence); IDecisionTreeInterface.ImportVariables(variables); return(true); } return(false); }
public void Dispose() { var currentArtRoot = ArtRoot; ArtRoot = null; if (_writting || _preapprovedWritting) { _keyValueDB.RevertWrittingTransaction(currentArtRoot); _writting = false; _preapprovedWritting = false; } else if (currentArtRoot != null) { _keyValueDB.DereferenceRoot(currentArtRoot); } GC.SuppressFinalize(this); }
public new void Dispose() { foreach (INode node in ChildNodes) { IRootNode rootNode = node as IRootNode; if (rootNode != null) { rootNode.SizeChanged -= RootNode_SizeChanged; } node.CheckedChanged -= Node_CheckedChanged; node.ActionTaken -= Node_ActionTaken; node.Dispose(); } base.Dispose(); }
internal IRootNode MakeWritableTransaction(ArtInMemoryKeyValueDBTransaction keyValueDBTransaction, IRootNode artRoot) { lock (_writeLock) { if (_writingTransaction != null) { throw new BTDBTransactionRetryException("Another writing transaction already running"); } if (_lastCommited != artRoot) { throw new BTDBTransactionRetryException("Another writing transaction already finished"); } _writingTransaction = keyValueDBTransaction; var result = _lastCommited.CreateWritableTransaction(); DereferenceRoot(artRoot); return(result); } }
public CursorTestsBase() { _allocator = new LeakDetectorWrapperAllocator(new HGlobalAllocator()); _root = ARTImpl.CreateEmptyRoot(_allocator, Is12); _cursor = _root.CreateCursor(); }
public ArtInMemoryKeyValueDB(IOffHeapAllocator allocator) { _lastCommited = ARTImplV.CreateEmptyRoot(allocator); _lastCommited.Commit(); }
/// <summary> /// Private constructor, used internally to create the childnodes of the root nodes. /// </summary> /// <param name="root"></param> /// <param name="parent"></param> /// <param name="level"></param> /// <param name="childrenCount"></param> /// <param name="maxDepth"></param> /// <param name="index"></param> private NodeViewModel( IRootNode root, NodeViewModel parent, int level, int childrenCount, int maxDepth, int index ) { ChildNodes = new ObservableCollection<NodeViewModel>(); Parent = parent; Root = root; Root.LevelChanged += OnLevelChanged; _level = level; _index = index; InitializeCoordinates( index ); if( _level < maxDepth ) { for( int i = 0; i < childrenCount; i++ ) { ChildNodes.Add( new NodeViewModel( root, this, _level + 1, childrenCount, maxDepth, i ) ); } } }
public string Print(IRootNode rootNode) { var root = rootNode.Root; return(""); }
public ArtInMemoryKeyValueDB(IOffHeapAllocator allocator) { _lastCommited = ARTImpl.CreateEmptyRoot(allocator, false); }
/// <summary> /// Returns Home Page. /// </summary> /// <typeparam name="T">Type of Home Page node to return.</typeparam> /// <param name="root">Site root node.</param> /// <returns>Home Page.</returns> public static T GetHome <T>(this IRootNode root) where T : class, IHomePage => root as T; // TODO: Change implementation of this method when Home page is not in the root of the site (i.e. for multi-language sites or when some kind of special Site node is in the root).
public void Run(IRootNode rootNode) { _tokens = rootNode.TokenDefs; _traverser.Traverse(rootNode.Syntax); }
protected CursorTestsBase() { _allocator = new LeakDetectorWrapperAllocator(new HGlobalAllocator()); _root = BTreeImpl12.CreateEmptyRoot(_allocator); _cursor = _root !.CreateCursor(); }