示例#1
0
        /// <summary>
        /// Cloning Constructor.
        /// Cloning the whole circuit is pretty difficult somehow!
        /// </summary>
        /// <param name="original">original object to create clone from</param>
        private Circuit(Circuit original)
        {
            //create connections to connect the cloned elements to
            List <Connection> connlist = new List <Connection>();

            foreach (BaseElement element in original.m_Elements)
            {
                if (element is Connection)
                {
                    Connection cloned = new Connection();
                    cloned.Name = element.Name;
                    connlist.Add(cloned);
                }
            }
            //clone elements
            foreach (BaseElement element in original.m_Elements)
            {
                if (element is InputOutputElement)
                {
                    InputOutputElement io     = element as InputOutputElement;
                    InputOutputElement cloned = io.Clone();
                    ConnectClonedTerminals(io, cloned, connlist);
                    AddElement(cloned);
                }
            }
            // add the connections to the circuit clone
            foreach (Connection connection in connlist)
            {
                if (connection.Terminals.Count > 0)
                {
                    AddElement(connection);
                }
            }
        }
示例#2
0
 public override void Logic()
 {
     //use matching to deploy states of Terminals to the SignalInputs within circuit
     foreach (Terminal terminal in Inputs)
     {
         InputOutputElement io = m_Matching.FindIOElement(terminal);
         if (io != null)
         {
             terminal.Update();
             (io as SignalInput).State = terminal.State;
             //io.Logic();
         }
     }
     //run circuit
     m_Circuit.Update();
     //use matching to deploy states of SignalOutputs within circuit to the Terminals
     for (int index = 0; index < Outputs.Length; index++)
     {
         InputOutputElement io = m_Matching.FindIOElement(Outputs[index]);
         if (io != null)
         {
             //io.Logic();
             m_PreStates[index] = (io as SignalOutput).State;
         }
     }
 }
示例#3
0
 /// <summary>
 /// Adds a new Matching
 /// </summary>
 /// <param name="terminal"></param>
 /// <param name="ioElement"></param>
 public void AddMatching(Terminal terminal, InputOutputElement ioElement)
 {
     if (ioElement is SignalInput == false && ioElement is SignalOutput == false)
     {
         throw new ArgumentException("Type of IOElement not supported for matching.");
     }
     m_MatchingDict.Add(terminal, ioElement);
 }
示例#4
0
 public override void AddElement(BaseElement element)
 {
     if (element is InputOutputElement)
     {
         InputOutputElement io = (element as InputOutputElement);
         io.UpdateIndex = m_NextIndex;
         m_NextIndex++;
         io.OnUpdateIndexChanged += new DigitalClasses.Events.UpdateIndexChanged(UpdateIndexChangedEventHandler);
     }
     base.AddElement(element);
     SortElements();
 }
示例#5
0
 /// <summary>
 /// Part of the cloning constructor.
 /// Connects the cloned terminals to the cloned connections.
 /// </summary>
 /// <param name="io">original element object</param>
 /// <param name="cloned">cloned element object</param>
 /// <param name="connlist">list with connections</param>
 private void ConnectClonedTerminals(InputOutputElement io, InputOutputElement cloned, List <Connection> connlist)
 {
     //inputs
     for (int i = 0; i < io.Inputs.Length; i++)
     {
         if (io.Inputs[i].IsConnected == false)
         {
             continue;
         }
         string     connectionName = io.Inputs[i].Connection.Name;
         Connection destConn       = connlist.Find(
             delegate(Connection connection)
         {
             if (connection.Name.Equals(connectionName))
             {
                 return(true);
             }
             return(false);
         }
             );
         if (destConn != null)
         {
             destConn.ConnectTerminal(cloned.Inputs[i]);
         }
     }
     //outputs
     for (int i = 0; i < io.Outputs.Length; i++)
     {
         if (io.Outputs[i].IsConnected == false)
         {
             continue;
         }
         string     connectionName = io.Outputs[i].Connection.Name;
         Connection destConn       = connlist.Find(
             delegate(Connection connection)
         {
             if (connection.Name.Equals(connectionName))
             {
                 return(true);
             }
             return(false);
         }
             );
         if (destConn != null)
         {
             destConn.ConnectTerminal(cloned.Outputs[i]);
         }
     }
 }
示例#6
0
        /// <summary>
        /// Handles index change by user. Those changes may need change in other indices.
        /// </summary>
        /// <param name="sender">element whose index was changed</param>
        /// <param name="e">EventArgs containing further information</param>
        private void UpdateIndexChangedEventHandler(object sender, UpdateIndexChangedEventArgs e)
        {
            if (m_IgnoreEvents)
            {
                return;
            }
            InputOutputElement senderio = sender as InputOutputElement;

            #region Old > New
            if (e.OldIndex > e.NewIndex)
            {
                //increase all indices between the new and the old value
                m_IgnoreEvents = true;
                foreach (BaseElement be in m_Elements)
                {
                    if (be is InputOutputElement)
                    {
                        InputOutputElement beio = be as InputOutputElement;
                        if (!beio.Equals(senderio) && beio.UpdateIndex >= e.NewIndex && beio.UpdateIndex < e.OldIndex)
                        {
                            beio.UpdateIndex++;
                        }
                    }
                }
                m_IgnoreEvents = false;
            }
            #endregion
            #region New > Old
            if (e.OldIndex < e.NewIndex)
            {
                //decrease all indices between the new and the old value
                m_IgnoreEvents = true;
                foreach (BaseElement be in m_Elements)
                {
                    if (be is InputOutputElement)
                    {
                        InputOutputElement beio = be as InputOutputElement;
                        if (!beio.Equals(senderio) && beio.UpdateIndex > e.OldIndex && beio.UpdateIndex <= e.NewIndex)
                        {
                            beio.UpdateIndex--;
                        }
                    }
                }
                m_IgnoreEvents = false;
            }
            #endregion
            SortElements();
        }
示例#7
0
        /// <summary>
        /// Find corresponding Terminal in reverse direction
        /// </summary>
        /// <param name="ioElement">IO to find Terminal for</param>
        /// <returns>Corresponsing Terminal or null if not found</returns>
        public Terminal FindTerminal(InputOutputElement ioElement)
        {
            InputOutputElement[] ioArray = new InputOutputElement[m_MatchingDict.Values.Count];
            m_MatchingDict.Values.CopyTo(ioArray, 0);
            Terminal[] termArray = new Terminal[m_MatchingDict.Keys.Count];
            m_MatchingDict.Keys.CopyTo(termArray, 0);

            if (m_MatchingDict.ContainsValue(ioElement))
            {
                for (int i = 0; i < m_MatchingDict.Values.Count; i++)
                {
                    if (ioElement.Equals(ioArray[i]))
                    {
                        return(termArray[i]);
                    }
                }
            }
            return(null);
        }
示例#8
0
 /// <summary>
 /// Updates all InputOutputElements within the circuit. Therefore their logic method will be run.
 /// </summary>
 public void Update()
 {
     //elements are sorted by type and the UpdateIndex,
     //when run the logic method is run, the result is stored internally
     foreach (BaseElement element in m_Elements)
     {
         InputOutputElement io = element as InputOutputElement;
         if (io != null)
         {
             io.Logic();
         }
     }
     //upon propagation the internal result is set to their outputs
     foreach (BaseElement element in m_Elements)
     {
         InputOutputElement io = element as InputOutputElement;
         if (io != null)
         {
             io.Propagate();
         }
     }
 }
示例#9
0
 public override bool RemoveElement(BaseElement element)
 {
     if (element is InputOutputElement)
     {
         InputOutputElement io = (element as InputOutputElement);
         io.OnUpdateIndexChanged -= UpdateIndexChangedEventHandler;
         m_IgnoreEvents           = true;
         foreach (BaseElement be in m_Elements)
         {
             if (be is InputOutputElement)
             {
                 InputOutputElement beio = be as InputOutputElement;
                 if (beio.UpdateIndex > io.UpdateIndex)
                 {
                     beio.UpdateIndex--;
                 }
             }
         }
         m_IgnoreEvents = false;
     }
     return(base.RemoveElement(element));
 }