コード例 #1
0
        private void loadFileToolStripMenuItem_Click(object sender, EventArgs e)
        {
            //SimpleGraphAdapter test, load
            cdbOpenModel.Filter = "Text Files (*.txt)|*.txt";
            DialogResult d = cdbOpenModel.ShowDialog();
            
            if (d != DialogResult.Cancel)
            {
                this.Cursor = Cursors.WaitCursor;
                Application.DoEvents();

                try
                {
                    oGraphAdapter = new SimpleGraphAdapter();
                    layoutControl1.SetAndShowGraph(oGraphAdapter.LoadGraphFromFile(cdbOpenModel.FileName));
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Error: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                this.Cursor = Cursors.Default;
                //Application.DoEvents();
            }
        }
コード例 #2
0
        protected void Configure(IDomainModel domainModel)
        {
            DebugContract.Requires(domainModel);
            if (_domainModel != null)
            {
                return;
            }

            _trace       = domainModel.Resolve <IHyperstoreTrace>(false) ?? new EmptyHyperstoreTrace();
            _domainModel = domainModel;

            var kv = _services.Resolve <IKeyValueStore>() ?? new Hyperstore.Modeling.MemoryStore.TransactionalMemoryStore(domainModel);

            _storage = kv;
            if (kv is IDomainService)
            {
                ((IDomainService)kv).SetDomain(domainModel);
            }
            _indexManager = new Hyperstore.Modeling.HyperGraph.Index.MemoryIndexManager(this); // TODO lier avec TransactionalMemoryStore
            _loader       = _services.Resolve <IGraphAdapter>();
            if (_loader is IDomainService)
            {
                ((IDomainService)_loader).SetDomain(domainModel);
            }
            _lazyLoader = _loader as ISupportsLazyLoading;
        }
コード例 #3
0
ファイル: Astar.cs プロジェクト: elpollouk/Advent2017
        public static IList <Node> FindPath <Node>(IGraphAdapter <Node> graph, Node start, Node goal)
        {
            var comparer    = EqualityComparer <Node> .Default;
            var searchSpace = new PriorityQueue <Node>();
            var pathMap     = new Dictionary <Node, Node>();
            var costSoFar   = new Dictionary <Node, int>();

            searchSpace.Enqueue(start, 0);
            costSoFar[start] = 0;

            while (searchSpace.Count != 0)
            {
                var current = searchSpace.Dequeue();
                if (comparer.Equals(current, goal))
                {
                    break;
                }

                var linked = graph.GetLinked(current);
                foreach (var linkedNode in linked)
                {
                    var newCost = costSoFar[current] + graph.GetMoveCost(current, linkedNode);
                    if (newCost < costSoFar.GetOrDefault(linkedNode, int.MaxValue))
                    {
                        costSoFar[linkedNode] = newCost;
                        searchSpace.Enqueue(linkedNode, newCost + graph.GetScore(linkedNode, goal));
                        pathMap[linkedNode] = current;
                    }
                }
            }

            return(ResolvePath(pathMap, start, goal));
        }
コード例 #4
0
        /// <summary>
        /// Computes the immediate dominator of each basic block.
        /// The default implementation directs the task to the Cooper-Harvey-Kennedy algorithm.
        /// </summary>
        protected virtual void ComputeDominators()
        {
            IGraphAdapter <BasicBlock <Ti> > a = BasicBlock <Ti> .DominanceAnalysisAdapter;

            a.InvertRelation(a.Succs, a.Preds, BasicBlocks);
            a.ComputeImmediateDominators(BasicBlocks, EntryCB);
        }
コード例 #5
0
 /// <summary>
 /// Creates a new list for each temporary list storage property.
 /// </summary>
 /// <param name="a">the graph adapter</param>
 /// <param name="nodes">enumeration of nodes whose temporary list storage properties are to be initialized</param>
 public static void CreateDefaultTempStorage <T>(this IGraphAdapter <T> a, IEnumerable <T> nodes)
 {
     a.TempList.RequireAccess(EAccess.WriteOnly);
     foreach (T node in nodes)
     {
         a.TempList[node] = new List <T>();
     }
 }
コード例 #6
0
        /// <summary>
        /// Analyzes the loop nesting structure of the control-flow graph.
        /// The default implementation directs the tasks to Havlak's algorithm.
        /// </summary>
        protected virtual void AnalyzeLoops()
        {
            IGraphAdapter <BasicBlock <Ti> > a = BasicBlock <Ti> .LoopAnalysisAdapter;

            BasicBlock <Ti>[] reachable = a.GetPreOrder(BasicBlocks, EntryCB);
            a.InvertRelation(a.Succs, a.Preds, reachable);
            a.AnalyzeLoops(reachable, EntryCB);
        }
コード例 #7
0
        public void TearDown()
        {
            m_oGraphAdapter = null;

            if ( File.Exists(m_sTempFileName) )
            {
            File.Delete(m_sTempFileName);
            }
        }
コード例 #8
0
 /// <summary>
 /// Computes a the immediate dominators of all specified graph nodes.
 /// </summary>
 /// <param name="a">graph adapter</param>
 /// <param name="nodes">nodes to consider</param>
 /// <param name="entry">entry node</param>
 public static void ComputeImmediateDominators <T>(this IGraphAdapter <T> a,
                                                   IList <T> nodes, T entry) where T : class
 {
     ComputeImmediateDominators(a.Succs, a.Preds, a.PostOrderIndex,
                                a.IDom, nodes, entry);
     a.IDom[entry] = null;
     a.InvertRelation(a.IDom, a.IDoms, nodes);
     a.IDom[entry] = entry;
 }
コード例 #9
0
 /// <summary>
 /// Constructor</summary>
 /// <param name="renderer">Graph renderer</param>
 /// <param name="graphAdapter">Graph adapter</param>
 /// <param name="transformAdapter">Transform adapter</param>
 public GraphEdgeEditAdapter(
     GraphRenderer <TNode, TEdge, TEdgeRoute> renderer,
     IGraphAdapter <TNode, TEdge, TEdgeRoute> graphAdapter,
     ITransformAdapter transformAdapter)
 {
     m_renderer         = renderer;
     m_graphAdapter     = graphAdapter;
     m_transformAdapter = transformAdapter;
 }
コード例 #10
0
        /// <summary>
        /// Performs a depth-first search on the successor relation, updating the pre-order index
        /// and pre-order last index relations of the graph adapter.
        /// </summary>
        /// <param name="a">graph adapter</param>
        /// <param name="nodes">nodes to be considered</param>
        /// <param name="start">start node</param>
        /// <returns>all visited nodes in pre-order</returns>
        public static T[] GetPreOrder <T>(this IGraphAdapter <T> a,
                                          IList <T> nodes, T start)
        {
            a.PreOrderIndex.Reset(nodes, -1);
            T[] result = new T[nodes.Count];
            int index  = 0;

            a.PreOrderDFS(result, start, ref index);
            // if some nodes are unreachable, the last elements of the result
            // array are null. These should be eliminated:
            result = result.Where(x => x != null).ToArray();
            return(result);
        }
コード例 #11
0
        private static void PreOrderDFS <T>(this IGraphAdapter <T> a,
                                            T[] result, T node, ref int index)
        {
            Contract.Requires <ArgumentNullException>(a != null);
            Contract.Requires <ArgumentNullException>(result != null);
            Contract.Requires <ArgumentException>(index >= 0);
            Contract.Requires <ArgumentException>(index < result.Length);

            result[index]         = node;
            a.PreOrderIndex[node] = index++;
            foreach (T child in a.Succs[node])
            {
                if (a.PreOrderIndex[child] < 0)
                {
                    a.PreOrderDFS(result, child, ref index);
                }
            }
            a.PreOrderLast[node] = result[index - 1];
        }
コード例 #12
0
 /// <summary>
 /// Inverts a property map-based relation.
 /// </summary>
 /// <param name="a">graph adapter providing temporary list storage</param>
 /// <param name="srcrel">source property map</param>
 /// <param name="dstrel">destination property map for inverted relation</param>
 /// <param name="nodes">nodes to be considered for the inversion</param>
 public static void InvertRelation <T>(this IGraphAdapter <T> a,
                                       IPropMap <T, T[]> srcrel, IPropMap <T, T[]> dstrel, IEnumerable <T> nodes)
 {
     a.CreateDefaultTempStorage(nodes);
     srcrel.RequireAccess(EAccess.ReadOnly);
     dstrel.RequireAccess(EAccess.WriteOnly);
     foreach (T node in nodes)
     {
         foreach (T adj in srcrel[node])
         {
             a.TempList[adj].Add(node);
         }
     }
     foreach (T node in nodes)
     {
         dstrel[node] = a.TempList[node].ToArray();
     }
     a.TempList.Clear(nodes);
 }
コード例 #13
0
        ///-------------------------------------------------------------------------------------------------
        /// <summary>
        ///  Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged
        ///  resources.
        /// </summary>
        ///-------------------------------------------------------------------------------------------------
        public void Dispose()
        {
            if (_disposed)
            {
                return;
            }

            if (_storage is IDisposable)
            {
                ((IDisposable)_storage).Dispose();
            }

            if (_loader is IDisposable)
            {
                ((IDisposable)_loader).Dispose();
            }

            _loader      = null;
            _storage     = null;
            _disposed    = true;
            _domainModel = null;
        }
コード例 #14
0
 ///-------------------------------------------------------------------------------------------------
 /// <summary>
 ///  Loads.
 /// </summary>
 /// <param name="adapter">
 ///  The adapter.
 /// </param>
 /// <param name="query">
 ///  The query.
 /// </param>
 /// <param name="option">
 ///  The option.
 /// </param>
 /// <returns>
 ///  Number of nodes loaded
 /// </returns>
 ///-------------------------------------------------------------------------------------------------
 public Task <int> LoadAsync(Query query = null, MergeOption option = MergeOption.OverwriteChanges, IGraphAdapter adapter = null)
 {
     return(InnerGraph.LoadNodes(query ?? new Query {
         DomainModel = this.Name
     }, option, adapter, false));
 }
コード例 #15
0
 /// <summary>
 /// Returns <c>true</c> if <paramref name="w"/> is an ancestor of <c>v</c>.
 /// </summary>
 public static bool IsAncestor <T>(this IGraphAdapter <T> a, T w, T v)
 {
     return(IsAncestor(a.PreOrderIndex, a.PreOrderLast, w, v));
 }
コード例 #16
0
        /// <summary>
        /// Determines the loop nesting structure of the given (control-flow) graph.
        /// </summary>
        /// <remarks>
        /// This is an implementation of Paul Havlak's loop analysis algorithm.
        /// Reference: ACM Transactions on Programming Languages and Systems, Vol. 19, No. 4, July 1997, Pages 557-567.
        /// </remarks>
        /// <param name="a">graph adapter</param>
        /// <param name="nodes">nodes to consider</param>
        /// <param name="start">entry node</param>
        public static void AnalyzeLoops <T>(this IGraphAdapter <T> a,
                                            IList <T> nodes, T start)
        {
            T[] order = a.GetPreOrder(nodes, start);

            // fix_loops part
#if false
            foreach (T w in order)
            {
                a.RedBackIn[w] = new HashSet <T>();
                a.OtherIn[w]   = new HashSet <T>();
                foreach (T v in a.Preds[w])
                {
                    if (a.PreOrderIndex[w] < a.PreOrderIndex[v])
                    {
                        a.RedBackIn[w].Add(v);
                    }
                    else
                    {
                        a.OtherIn[w].Add(v);
                    }
                }
                if (a.RedBackIn[w].Count > 0 && a.OtherIn[w].Count > 1)
                {
                    throw new NotImplementedException();
                }
            }
#endif

            foreach (T w in order /*nodes*/)
            {
                a.BackPreds[w]    = new HashSet <T>();
                a.NonBackPreds[w] = new HashSet <T>();
                a.Header[w]       = start;
                a.Type[w]         = ENodeType.Nonheader;
                foreach (T v in a.Preds[w])
                {
                    if (a.IsAncestor(w, v))
                    {
                        a.BackPreds[w].Add(v);
                    }
                    else
                    {
                        a.NonBackPreds[w].Add(v);
                    }
                }
            }
            a.Header[start] = default(T);
            HashSet <T>   P  = new HashSet <T>();
            UnionFind <T> uf = new PreOrderSetAdapter <T>(a).CreateUnionFind(order);
            for (int iw = order.Length - 1; iw >= 0; iw--)
            {
                T w = order[iw];
                P.Clear();
                foreach (T v in a.BackPreds[w])
                {
                    if (!v.Equals(w))
                    {
                        P.Add(uf.Find(v));
                    }
                    else
                    {
                        a.Type[w] = ENodeType.Self;
                    }
                }
                Queue <T> worklist = new Queue <T>(P);
                if (P.Count > 0)
                {
                    a.Type[w] = ENodeType.Reducible;
                }
                while (worklist.Count > 0)
                {
                    T x = worklist.Dequeue();
                    foreach (T y in a.NonBackPreds[x])
                    {
                        T y_ = uf.Find(y);
                        if (!a.IsAncestor(w, y_))
                        {
                            a.Type[w] = ENodeType.Irreducible;
                            a.NonBackPreds[w].Add(y_);
                        }
                        else if (!P.Contains(y_) && !w.Equals(y_))
                        {
                            P.Add(y_);
                            worklist.Enqueue(y_);
                        }
                    }
                }
                foreach (T x in P)
                {
                    a.Header[x] = w;
                    uf.Union(x, w);
                }
            }
        }
コード例 #17
0
        public void SetUp()
        {
            m_oGraphAdapter = new PajekGraphAdapter();

            m_sTempFileName = Path.GetTempFileName();
        }
コード例 #18
0
 //*************************************************************************
 //  Constructor: PajekGraphAdapterTest()
 //
 /// <summary>
 /// Initializes a new instance of the <see cref="PajekGraphAdapterTest" />
 /// class.
 /// </summary>
 //*************************************************************************
 public PajekGraphAdapterTest()
 {
     m_oGraphAdapter = null;
     m_sTempFileName = null;
 }
コード例 #19
0
            public PreOrderSetAdapter(IGraphAdapter <T> a)
            {
                Contract.Requires <ArgumentNullException>(a != null);

                Index = a.PreOrderIndex;
            }
コード例 #20
0
 //*************************************************************************
 //  Constructor: GraphMLGraphAdapterTest()
 //
 /// <summary>
 /// Initializes a new instance of the <see cref="GraphMLGraphAdapterTest" />
 /// class.
 /// </summary>
 //*************************************************************************
 public GraphMLGraphAdapterTest()
 {
     m_oGraphAdapter = null;
     m_sTempFileName = null;
 }
コード例 #21
0
        public Task <int> LoadNodes(Query query, MergeOption option, IGraphAdapter adapter, bool lazyLoading)
        {
            if (adapter == null)
            {
                adapter = _loader;
            }

            var tcs = new TaskCompletionSource <int>();
            var cx  = 0;

            if (adapter == null)
            {
                tcs.TrySetResult(cx);
                return(tcs.Task);
            }
            var oldLazyLoader = _lazyLoader;

            try
            {
                // Disable lazy loading
                _lazyLoader = null;

                var q = adapter is ISupportsLazyLoading && lazyLoading ? ((ISupportsLazyLoading)adapter).LazyLoadingNodes(query) : adapter.LoadNodes(query);
                using (var session = this.Store.BeginSession(new SessionConfiguration {
                    Mode = SessionMode.Loading | SessionMode.SkipConstraints
                }))
                {
                    foreach (var result in q)
                    {
                        if (Session.Current != null && Session.Current.TrackingData.GetTrackedElementState(result.Id) == TrackingState.Removed)
                        {
                            continue;
                        }
                        cx++;
                        var newInCache    = false;
                        var nodeMetaclass = result.SchemaInfo;

                        // Si ce noeud n'existe pas dans le cache, on le met
                        GraphNode graphNode;
                        GetGraphNode(result.Id, result.NodeType, out graphNode);
                        var node = graphNode as GraphNode;
                        if (node == null)
                        {
                            if (result.NodeType == NodeType.Edge)
                            {
                                var rSchema = nodeMetaclass as ISchemaRelationship;
                                node = CreateRelationship(result.Id,
                                                          rSchema,
                                                          result.StartId,
                                                          result.EndId
                                                          ) as GraphNode;
                            }
                            else
                            {
                                node = CreateEntity(result.Id, nodeMetaclass as ISchemaEntity) as GraphNode;
                            }
                            newInCache = true;
                        }

                        if (option == MergeOption.AppendOnly && newInCache || option == MergeOption.OverwriteChanges)
                        {
                            foreach (var edge in result.Outgoings)
                            {
                                var edgeSchema = _domainModel.Store.GetSchemaRelationship(edge.SchemaId);
                                node = node.AddEdge(edge.Id, edgeSchema, Direction.Outgoing, edge.EndId);
                            }
                            foreach (var edge in result.Incomings)
                            {
                                var edgeSchema = _domainModel.Store.GetSchemaRelationship(edge.SchemaId);
                                node = node.AddEdge(edge.Id, edgeSchema, Direction.Incoming, edge.EndId);
                            }
                        }

                        var ctx = new SerializationContext(_domainModel, result.SchemaInfo, result);
                        var mel = (IModelElement)result.SchemaInfo.Deserialize(ctx);
                        if (mel != null)
                        {
                            if (result.Properties != null)
                            {
                                foreach (var property in result.Properties)
                                {
                                    // Mise à jour des propriétés lues
                                    if (option == MergeOption.AppendOnly && newInCache || option == MergeOption.OverwriteChanges)
                                    {
                                        SetPropertyValue(mel, property.Key, property.Value.Value, property.Value.CurrentVersion);
                                    }
                                    else if (option == MergeOption.PreserveChanges)
                                    {
                                        if (GetPropertyValue(node.Id, property.Key) == null)
                                        {
                                            SetPropertyValue(mel, property.Key, property.Value.Value, property.Value.CurrentVersion);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    session.AcceptChanges();
                }
                tcs.TrySetResult(cx);
            }
            catch (Exception ex)
            {
                tcs.SetException(ex);
            }
            finally
            {
                _lazyLoader = oldLazyLoader;
            }

            return(tcs.Task);
        }
コード例 #22
0
 /// <summary>
 /// Inverts a parent relation, taking the successor relation as target.
 /// </summary>
 /// <param name="a">graph adapter providing the relations</param>
 /// <param name="nodes">nodes to be considered</param>
 public static void ComputeSuccessorsFromParent <T>(this IGraphAdapter <T> a, IEnumerable <T> nodes)
 {
     a.InvertRelation(a.Parent, a.Succs, nodes);
 }
コード例 #23
0
 /// <summary>
 /// Inverts a successor relation, taking the predecessor relation as target.
 /// </summary>
 /// <param name="a">graph adapter providing the relations</param>
 /// <param name="nodes">nodes to be considered</param>
 public static void ComputePredecessorsFromSuccessors <T>(this IGraphAdapter <T> a, IEnumerable <T> nodes)
 {
     a.InvertRelation(a.Succs, a.Preds, nodes);
 }