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();
}
