#if X64
using size_t = System.UInt64;
using h_index_t = System.Int64;
#else
using size_t = System.UInt32;
using h_index_t = System.Int32;
#endif
#if H_DOUBLE
using h_number_t = System.Double;
#else
using h_number_t = System.Single;
#endif
          

#if X64
using size_t = System.UInt64;
using h_index_t = System.Int64;
#else
using size_t = System.UInt32;
using h_index_t = System.Int32;
#endif
#if H_DOUBLE
using h_number_t = System.Double;
#else
using h_number_t = System.Single;
#endif

using System;
using HAPI;

namespace Example
{
    public class LoadAndPropagate
    {
        /// <summary>
        /// This function parses the given NET file, compiles the network,
        /// and prints the prior beliefs and expected utilities of all
        /// nodes.  If a case file is given, the function loads the file,
        /// propagates the evidence, and prints the updated results.
        /// 
        /// If the network is a LIMID, we assume that we should compute
        /// policies for all decisions (rather than use the ones specified
        /// in the NET file).  Likewise, we update the policies when new
        /// evidence arrives.
        /// </summary<
        public static void LAP(String netName, String caseName)
        {
            try
            {
                ParseListener parseListener = new DefaultClassParseListener();
                Domain domain = new Domain(netName + ".net", parseListener);
                domain.OpenLogFile(netName + ".log");
                domain.Triangulate(Domain.TriangulationMethod.H_TM_BEST_GREEDY);
                domain.Compile();
                domain.CloseLogFile();

                bool hasUtilities = ContainsUtilities(domain.GetNodes());

                if (!hasUtilities)
                    Console.WriteLine("Prior beliefs:");
                else
                {
                    domain.UpdatePolicies();
                    Console.WriteLine("Overall expected utility: "
                                + domain.GetExpectedUtility());
                    Console.WriteLine();
                    Console.WriteLine("Prior beliefs (and expected utilities):");
                }
                PrintBeliefsAndUtilities(domain);

                if (caseName != null)
                {
                    domain.ParseCase(caseName, parseListener);

                    Console.WriteLine();
                    Console.WriteLine();
                    Console.WriteLine("Propagating the evidence specified in \""
                                + caseName + "\"");

                    domain.Propagate(Domain.Equilibrium.H_EQUILIBRIUM_SUM,
                              Domain.EvidenceMode.H_EVIDENCE_MODE_NORMAL);

                    Console.WriteLine();
                    Console.WriteLine("P(evidence) = "
                                + domain.GetNormalizationConstant());
                    Console.WriteLine();

                    if (!hasUtilities)
                        Console.WriteLine("Updated beliefs:");
                    else
                    {
                        domain.UpdatePolicies();
                        Console.WriteLine("Overall expected utility: "
                                + domain.GetExpectedUtility());
                        Console.WriteLine();
                        Console.WriteLine("Updated beliefs (and expected utilities):");
                    }
                    PrintBeliefsAndUtilities(domain);
                }

                domain.Delete();
            }
            catch (ExceptionHugin e)
            {
                Console.WriteLine("Exception caught: " + e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("General exception: " + e.Message);
                Console.WriteLine(e.StackTrace.ToString());
            }
        }


        /// <summary>
        /// Print the beliefs and expected utilities of all nodes in the domain.
        /// </summary>
        public static void PrintBeliefsAndUtilities(Domain domain)
        {
            NodeList nodes = domain.GetNodes();
            bool hasUtilities = ContainsUtilities(nodes);
            foreach (Node node in nodes)
            {
                Console.WriteLine();
                Console.WriteLine(node.GetLabel() + " (" + node.GetName() + ")");

                if (node is UtilityNode)
                    Console.WriteLine("  - Expected utility: "
                                + ((UtilityNode)node).GetExpectedUtility());
                else if (node is DiscreteNode)
                {
                    DiscreteNode dNode = (DiscreteNode)node;

                    for (size_t i = 0, n = dNode.GetNumberOfStates(); i < n; i++)
                    {
                        Console.WriteLine("  - " + dNode.GetStateLabel(i)
                                  + " " + dNode.GetBelief(i));
                        if (hasUtilities)
                            Console.WriteLine(" (" + dNode.GetExpectedUtility(i) + ")");
                        else
                            Console.WriteLine();
                    }
                }
                else if (node is FunctionNode)
                {
                    FunctionNode fNode = (FunctionNode)node;
                    try {
                        double value = fNode.GetValue();
                        Console.WriteLine("  - Function value : " + value);
                    } catch (ExceptionHugin) {
                        Console.WriteLine("  - Function value : N/A");
                    }
                }
                else
                {
                    ContinuousChanceNode ccNode = (ContinuousChanceNode)node;

                    Console.WriteLine("  - Mean : " + ccNode.GetMean());
                    Console.WriteLine("  - SD   : " + Math.Sqrt(ccNode.GetVariance()));
                }
            }
        }


        /// <summary>
        /// Are there utility nodes in the list?
        /// </summary>
        public static bool ContainsUtilities(NodeList list)
        {
            foreach (Node node in list)
            {
                if (node is UtilityNode)
                    return true;
            }

            return false;
        }


        /// <summary>
        /// Load a HUGIN NET file, compile the network, and print the
        /// results.  If a case file is specified, load it, propagate the
        /// evidence, and print the results.
        /// </summary>
        public static void Main(String[] args)
        {
            if (args.Length == 1)
                LAP(args[0], null);
            else if (args.Length == 2)
                LAP(args[0], args[1]);
            else
                Console.Error.WriteLine("Usage: <netName> [<caseName>]");
        }

    }
}
        

#if X64
using size_t = System.UInt64;
using h_index_t = System.Int64;
#else
using size_t = System.UInt32;
using h_index_t = System.Int32;
#endif
#if H_DOUBLE
using h_number_t = System.Double;
#else
using h_number_t = System.Single;
#endif

using System;
using System.Drawing;

using HAPI;

namespace Example
{
    public class BAP
    {
        protected Domain domain;

        //Build a Bayesian network and propagate evidence.
        public BAP()
        {
            domain = new Domain();

            BuildNetwork();

            domain.SaveAsNet("builddomain.net");
            domain.Compile();

            PropagateEvidenceInNetwork();
        }

        //Propagate evidence in domain.
        protected void PropagateEvidenceInNetwork()
        {
            domain.Propagate(Domain.Equilibrium.H_EQUILIBRIUM_SUM, Domain.EvidenceMode.H_EVIDENCE_MODE_NORMAL);
            PrintNodeMarginals(domain);
        }

        //print node marginals.
        protected void PrintNodeMarginals(Domain d)
        {
            NodeList nlist = domain.GetNodes();

            foreach (Node n in nlist)
            {
                DiscreteChanceNode node = (DiscreteChanceNode)n;
                size_t nStates = node.GetNumberOfStates();
                Console.WriteLine(node.GetLabel());
                for (size_t i = 0; i < nStates; i++)
                {
                    Console.WriteLine("-" + node.GetStateLabel(i) + " " + node.GetBelief(i));
                }
            }
        }

        //Construct numbered discrete chance node.
        protected NumberedDCNode ConstructNDC(String label, String name, size_t n)
        {
            NumberedDCNode node = new NumberedDCNode(domain);

            node.SetNumberOfStates(n);

            for (size_t i = 0; i < n; i++)
            {
                node.SetStateValue(i, i);
            }
            node.SetLabel(label);
            node.SetName(name);

            return node;
        }

        //Build the structure.
        protected void BuildStructure(NumberedDCNode A, NumberedDCNode B, NumberedDCNode C)
        {
            C.AddParent(A);
            C.AddParent(B);

            A.SetPosition(new Point(100, 200));
            B.SetPosition(new Point(200, 200));
            C.SetPosition(new Point(150, 50));
        }

        //Expression for C
        protected void BuildExpressionForC(NumberedDCNode A, NumberedDCNode B, NumberedDCNode C)
        {
            NodeList modelNodes = new NodeList();

            Model model = new Model(C, modelNodes);

            NodeExpression exprA = new NodeExpression(A);
            NodeExpression exprB = new NodeExpression(B);

            AddExpression exprC = new AddExpression(exprA, exprB);

            model.SetExpression(0, exprC);
        }

        //Specify the prior distribution of A and B.
        protected void SpecifyDistributions(NumberedDCNode A, NumberedDCNode B)
        {
            Table table = A.GetTable();
            h_number_t[] data = table.GetData();

            data[0] = (h_number_t)0.1;
            data[1] = (h_number_t)0.2;
            data[2] = (h_number_t)0.7;
            table.SetData(data);

            table = B.GetTable();
            data = table.GetData();
            data[0] = (h_number_t)0.2;
            data[1] = (h_number_t)0.2;
            data[2] = (h_number_t)0.6;
            table.SetData(data);
        }

        //Build the Bayesian network.
        public void BuildNetwork()
        {
            domain.SetNodeSize(new Size(50, 30));

            NumberedDCNode A = ConstructNDC("A1234567890123", "A", 3);
            NumberedDCNode B = ConstructNDC("B", "B", 3);

            NumberedDCNode C = ConstructNDC("C", "C", 5);

            BuildStructure(A, B, C);

            BuildExpressionForC(A, B, C);

            SpecifyDistributions(A, B);
        }

        //Build a Bayesian network and perform a propagation of
        //evidence. Print the results.
        public static int Main()
        {
            try
            {
                new BAP();
            }
            catch (ExceptionHugin e)
            {
                Console.WriteLine(e);
                return -1;
            }
            return 0;
        }
    }
}
        

#if X64
using size_t = System.UInt64;
using h_index_t = System.Int64;
#else
using size_t = System.UInt32;
using h_index_t = System.Int32;
#endif
#if H_DOUBLE
using h_number_t = System.Double;
#else
using h_number_t = System.Single;
#endif

using System;
using HAPI;

namespace Example
{
    public class Adapt
    {
        public Adapt(String fileName)
        {
            String netFileName = fileName + ".net";
            Domain d = new Domain(netFileName, new DefaultClassParseListener());
            String logFileName = fileName + ".log";
            d.OpenLogFile(logFileName);
            d.Compile();

            SpecifyLearningParameters(d);
            PrintLearningParameters(d);

            EnterCase(d);

            PrintCase(d);

            d.Propagate(Domain.Equilibrium.H_EQUILIBRIUM_SUM, Domain.EvidenceMode.H_EVIDENCE_MODE_NORMAL);

            d.Adapt();

            d.Initialize();

            PrintNodeMarginals(d);

            d.SaveAsNet("q.net");
        }

        private void SpecifyLearningParameters(Domain d)
        {
            NodeList nl = d.GetNodes();
            h_number_t[] data;

            foreach (DiscreteChanceNode node in nl)
            {
                Table table = node.GetExperienceTable();
                data = new h_number_t[table.GetSize()];
                for (size_t i = 0; i < table.GetSize(); i++)
                    data[i] = 1;
                table.SetData(data);
            }

            foreach (DiscreteChanceNode node in nl)
            {
                Table table = node.GetFadingTable();
                data = new h_number_t[table.GetSize()];
                for (size_t i = 0; i < table.GetSize(); i++)
                    data[i] = 1;
                table.SetData(data);
            }
        }

        private void PrintLearningParameters(Domain d)
        {
            NodeList nl = d.GetNodes();

            foreach (DiscreteChanceNode dcNode in nl)
            {
                Console.WriteLine(dcNode.GetLabel() + " (" + dcNode.GetName() + "): ");
                Console.Write("   ");
                if (dcNode.HasExperienceTable())
                {
                    Table table = dcNode.GetExperienceTable();
                    h_number_t[] data = table.GetData();
                    size_t tblSize = table.GetSize();

                    for (size_t i = 0; i < tblSize; i++)
                        Console.Write(data[i] + " ");
                    Console.WriteLine();
                }
                else
                    Console.WriteLine("No experience table");

                Console.Write("   ");
                if (dcNode.HasFadingTable())
                {
                    Table table = dcNode.GetFadingTable();
                    h_number_t[] data = table.GetData();
                    size_t tblSize = table.GetSize();

                    for (size_t i = 0; i < tblSize; i++)
                        Console.Write(data[i] + " ");
                    Console.WriteLine();
                }
                else
                    Console.WriteLine("No fading table");
            }
        }

        private void EnterCase(Domain d)
        {
            NodeList nl = d.GetNodes();

            foreach (DiscreteChanceNode dcNode in nl)
            {
                dcNode.SelectState(0);
            }
            DiscreteChanceNode node = (DiscreteChanceNode)nl[1];
            node.RetractFindings();
        }

        private void PrintCase(Domain d)
        {
            NodeList nl = d.GetNodes();

            foreach (DiscreteChanceNode dcNode in nl)
            {
                Console.Write(" (" + dcNode.GetName() + ",");
                if (dcNode.EvidenceIsEntered())
                    Console.Write(" evidence is entered) ");
                else
                    Console.Write(" evidence is not entered) ");
            }
            Console.WriteLine();
        }

        private void PrintNodeMarginals(Domain d)
        {
            NodeList nl = d.GetNodes();

            foreach (DiscreteChanceNode dcNode in nl)
            {
                size_t nStates = dcNode.GetNumberOfStates();

                Console.WriteLine(dcNode.GetLabel() + " (" + dcNode.GetName() + ")");
                for (size_t i = 0; i < nStates; i++)
                    Console.WriteLine(" - " + dcNode.GetStateLabel(i) + ": " + dcNode.GetBelief(i));
            }
        }

        public static void Main(String[] args)
        {
            try
            {
                new Adapt(args[0]);
            }
            catch (ExceptionHugin eh)
            {
                Console.WriteLine(eh);
            }
        }
    }
}
        

#if X64
using size_t = System.UInt64;
using h_index_t = System.Int64;
#else
using size_t = System.UInt32;
using h_index_t = System.Int32;
#endif
#if H_DOUBLE
using h_number_t = System.Double;
#else
using h_number_t = System.Single;
#endif


using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using HAPI;

namespace Example
{
    public class HuginControl : System.Windows.Forms.Panel
    {
        private Domain domain = null;

        public HuginControl()
        {
            BackColor = Color.White;
            BorderStyle = BorderStyle.Fixed3D;
            AutoScroll = true;
        }


        public void GetDomainFromFile(String path)
        {
            try
            {
                Domain dom = new Domain(path, new DefaultClassParseListener());
                Controls.Clear();
                if (domain != null && domain.IsAlive() == true)
                    domain.Delete();
                domain = dom;
                domain.Compile();

                //populate nodes
                NodeList list = dom.GetNodes();
                foreach (Node node in list)
                {
                    if (node is DiscreteChanceNode)
                    {
                        Controls.Add(new VisibleDCNode((DiscreteChanceNode)node));
                    }
                    else
                    {
                        Controls.Add(new VisibleNode(node));
                    }
                }
                Refresh();
            }
            catch (ExceptionHugin eh)
            {
                MessageBox.Show(eh.Message);
            }
        }

        protected override void OnPaintBackground(PaintEventArgs e)
        {
            try
            {
                base.OnPaintBackground(e);
                if (domain != null && domain.IsAlive())
                {
                    NodeList list = domain.GetNodes();
                    foreach (Node node in list)
                        foreach (Node n in node.GetChildren())
                        {
                            //draw link
                            Point locationOffset = new Point(domain.GetNodeSize().Width / 2, 
                                                              domain.GetNodeSize().Height / 2);
                            Point from = node.GetPosition();
                            from.Offset(AutoScrollPosition);
                            from.Offset(locationOffset);
                            Point to = n.GetPosition();
                            to.Offset(AutoScrollPosition);
                            to.Offset(locationOffset);
                            e.Graphics.DrawLine(Pens.Black, from, to);

                            //draw arrow head
                            float scaleX = domain.GetNodeSize().Width / 2;
                            float scaleY = domain.GetNodeSize().Height / 2;
                            float scaleCos = (to.X - from.X) * ((float)domain.GetNodeSize().Height 
                                              / (float)domain.GetNodeSize().Width);
                            float scaleSin = to.Y - from.Y;
                            float norm1 = 1f / (float)Math.Sqrt(scaleCos * scaleCos + scaleSin * scaleSin);
                            scaleCos *= norm1;
                            scaleSin *= norm1;
                            float cos = to.X - from.X;
                            float sin = to.Y - from.Y;
                            float norm2 = 1f / (float)Math.Sqrt(cos * cos + sin * sin);
                            cos *= norm2;
                            sin *= norm2;
                            PointF[] arrow = {new PointF( to.X - scaleCos * scaleX-cos*20 - sin*10,
                                                          to.Y - scaleSin * scaleY - sin*20 + cos*10),
                                new PointF(to.X - scaleCos * scaleX, to.Y - scaleSin * scaleY),
                                new PointF( to.X - scaleCos * scaleX-cos*20 + sin*10, 
                                            to.Y - scaleSin * scaleY - sin*20 - cos*10),
                            };
                            e.Graphics.DrawLines(Pens.Black, arrow);
                        }
                }
            }
            catch (ExceptionHugin eh)
            {
                MessageBox.Show(eh.Message);
            }
        }

        public class VisibleDCNode : System.Windows.Forms.UserControl
        {
            private DCMonitor monitor;
            private DiscreteChanceNode node;

            public VisibleDCNode(DiscreteChanceNode dcNode)
            {
                node = dcNode;
                Size = node.GetHome().GetNodeSize();
                Location = node.GetPosition(); 
                monitor = new DCMonitor(node);
                MouseClick += MouseClickHandler;
            }

            private void MouseClickHandler(object sender, System.Windows.Forms.MouseEventArgs e)
            {
                if (!Parent.Controls.Contains(monitor))
                {
                    monitor.Location = Location;
                    Parent.Controls.Add(monitor);
                    monitor.BringToFront();
                }
                else if (Parent.Controls.Contains(monitor))
                    Parent.Controls.Remove(monitor);
            }

            protected override CreateParams CreateParams
            {
                get
                {
                    CreateParams cp = base.CreateParams;
                    cp.ExStyle |= 0x20;
                    return cp;
                }
            }

            protected override void OnPaintBackground(PaintEventArgs e)
            {
                //empty
            }

            protected override void OnPaint(PaintEventArgs pevent)
            {
                pevent.Graphics.FillEllipse(Brushes.LightYellow, 0, 0, Width - 1, Height - 1);
                pevent.Graphics.DrawEllipse(Pens.Black, 0, 0, Width - 1, Height - 1);
                pevent.Graphics.DrawString(node.GetName() + ": " + node.GetLabel(), 
                      new Font("Microsoft Sans Serif", 8.25f), Brushes.Black, 10f, Height / 2 - 5);
            }
        }

        public class DCMonitor : System.Windows.Forms.FlowLayoutPanel
        {
            private DiscreteChanceNode node;
            private Point clickLocation = new Point(0, 0);

            public DCMonitor(DiscreteChanceNode dcNode)
            {
                node = dcNode;
                MouseMove += MouseMoveHandler;
                MouseClick += MouseClickHandler;
                BackColor = Color.White;
                BorderStyle = BorderStyle.FixedSingle;
                AutoScroll = true;
                FlowDirection = FlowDirection.TopDown;
                WrapContents = false;
                Width = 180;
                Height = 150;
                Label lbl = new Label();
                lbl.Text = node.GetName() + ": " + node.GetLabel();
                lbl.MouseClick += MouseClickHandler;
                lbl.MouseMove += MouseMoveHandler;
                Controls.Add(lbl);
                for (size_t i = 0; i < node.GetNumberOfStates(); i++)
                {
                    Controls.Add(new State(node, i));
                }
            }

            private void MouseClickHandler(object sender, System.Windows.Forms.MouseEventArgs e)
            {
                BringToFront();
            }

            private void MouseMoveHandler(object sender, System.Windows.Forms.MouseEventArgs e)
            {
                if (e.Button == MouseButtons.None)
                    clickLocation = new Point(0, 0);

                if (e.Button == MouseButtons.Left && clickLocation.X != 0)
                {
                    int movementX = e.Location.X - clickLocation.X;
                    int movementY = e.Location.Y - clickLocation.Y;
                    Location = new Point(Location.X + movementX, Location.Y + movementY);
                }

                if (e.Button == MouseButtons.Left && clickLocation.X == 0)
                {
                    clickLocation = e.Location;
                }
            }

            private void RedrawNet()
            {
                Parent.Refresh();
            }

            private class State : System.Windows.Forms.UserControl
            {
                size_t stateNumber = 0;
                DiscreteChanceNode node;

                public State(DiscreteChanceNode dcNode, size_t state)
                {
                    Width = 140;
                    Height = 20;
                    BackColor = Color.White;
                    stateNumber = state;
                    node = dcNode;
                    MouseDoubleClick += MouseDoubleClickHandler;

                }

                private void MouseDoubleClickHandler(object sender, System.Windows.Forms.MouseEventArgs e)
                {
                    try
                    {
                        if (node.EvidenceIsEntered() && node.GetBelief(stateNumber) > 0)
                            node.RetractFindings();
                        else
                            node.SelectState(stateNumber);
                        node.GetHomeDomain().Propagate(Domain.Equilibrium.H_EQUILIBRIUM_SUM, 
                                                       Domain.EvidenceMode.H_EVIDENCE_MODE_NORMAL);
                        ((DCMonitor)Parent).RedrawNet();
                    }
                    catch (ExceptionHugin eh)
                    {
                        MessageBox.Show(eh.Message);
                    }
                }

                protected override void OnPaint(PaintEventArgs e)
                {
                    try
                    {
                        base.OnPaint(e);
                        Graphics g = e.Graphics;
                        Brush fillBrush = node.EvidenceIsEntered() ? Brushes.Red : Brushes.Green;
                        g.FillRectangle(fillBrush, 0, 0, (float)((Width - 1) * node.GetBelief(stateNumber)),
                                        Height - 1);
                        String text = node.GetStateLabel(stateNumber) + " " + node.GetBelief(stateNumber);
                        g.DrawString(text, new Font("Microsoft Sans Serif", 8.25f), 
                                      Brushes.Black, 10f, Height / 2 - 5);
                        g.DrawRectangle(Pens.Black, 0, 0, Width - 1, Height - 1);
                    }
                    catch (ExceptionHugin eh)
                    {
                        MessageBox.Show(eh.Message);
                    }
                }
            }
        }

        public class VisibleNode : System.Windows.Forms.UserControl
        {
            private Node node;

            public VisibleNode(Node theNode)
            {
                node = theNode;
                Size = node.GetHome().GetNodeSize();
                Location = node.GetPosition(); 
                MouseClick += MouseClickHandler;
            }

            private void MouseClickHandler(object sender, System.Windows.Forms.MouseEventArgs e)
            {
                MessageBox.Show(node.GetKind().ToString(), "Node Type");
            }

            protected override CreateParams CreateParams
            {
                get
                {
                    CreateParams cp = base.CreateParams;
                    cp.ExStyle |= 0x20;
                    return cp;
                }
            }

            protected override void OnPaintBackground(PaintEventArgs e)
            {
                //empty
            }

            protected override void OnPaint(PaintEventArgs pevent)
            {
                pevent.Graphics.FillEllipse(Brushes.Gray, 0, 0, Width - 1, Height - 1);
                pevent.Graphics.DrawEllipse(Pens.Black, 0, 0, Width - 1, Height - 1);
                pevent.Graphics.DrawString(node.GetName() + ": " + node.GetLabel(), 
                      new Font("Microsoft Sans Serif", 8.25f), Brushes.Black, 10f, Height / 2 - 5);
            }
        }


    }
}

        private void button1_Click(object sender, EventArgs e)
        {
            openFileDialog1.ShowDialog();
            if (openFileDialog1.FileName != "")
                huginControl1.GetDomainFromFile(openFileDialog1.FileName);
        }

#if X64
using size_t = System.UInt64;
using h_index_t = System.Int64;
#else
using size_t = System.UInt32;
using h_index_t = System.Int32;
#endif
#if H_DOUBLE
using h_number_t = System.Double;
#else
using h_number_t = System.Single;
#endif

using System;
using HAPI;

namespace Example
{
    public class NodeNaming
    {
        //The HUGIN GUI saves classes with an ".oobn" extension. The OOBNParseListener tries to load a nested class by
        //looking for the class in a file with the name className + ".oobn"
        public class OOBNParseListener : ClassParseListener
        {
            public void ParseError(size_t position, String msg)
            {
                Console.Error.WriteLine("Parse error location: " + position + " : " + msg);
            }

            public void InsertClass(String className, ClassCollection cc)
            {
                try
                {
                    cc.ParseClasses(className + ".oobn", this);
                }
                catch (ExceptionHugin e)
                {
                    Console.Error.WriteLine("Parsing failed: " + e.Message);
                }
            }
        }

        //Print the name of each node in the list.
        public static void PrintNodes(NodeList list)
        {
            foreach (Node n in list)
            {
                Console.Write(n.GetName() + " ");
            }
            Console.WriteLine();
        }


        //Load a hugin Object Oriented Bayesian Network, unfold classes to a domain and print out the node names.
        public static int Main(String[] args)
        {
            if (args.Length < 1)
            {
                Console.WriteLine("Usage: NodeNaming <classname>");
                Console.WriteLine("(the class <classname> is located in the file \"<classname>.oobn\")");
                return -1;
            }
            try
            {
                String className = args[0];
                ClassCollection cc = new ClassCollection();
                Console.WriteLine("Parsing classes..");
                cc.ParseClasses(className + ".oobn", new OOBNParseListener());
                Class myClass = cc.GetClassByName(className);
                if (myClass == null)
                {
                    Console.Error.WriteLine("Class is NULL");
                    return -1;
                }
                else
                {
                    foreach (Class c in cc.GetMembers()) {
                        Console.WriteLine("Nodes in class: " + c.GetName());
                        PrintNodes(c.GetNodes());
                    }
                    Console.WriteLine("\nNodes in runtime domain:");
                    Domain dom = myClass.CreateDomain();
                    PrintNodes(dom.GetNodes());
                    dom.Delete();
                    cc.Delete();
                }
            }
            catch (ExceptionHugin e)
            {
                Console.WriteLine(e);
                return -1;
            }
            return 0;
        }
    }
}