using System;
using System.IO;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Windows.Forms;

// own namespaces
using debug;
using global;

/// @brief basic_structur ist die Daten Basis Struktur auf die alles aufbaut. Sie bildet die in der
///        realen Welt existierenden Elemente wie Gleise, Weichen, Signale etc. in Klassen ab, von
///        Denen man dann Instanzen erzeugen kann um diese dann mit Daten zu füllen.
/// 
/// @author Marcel Hotopp
///
/// @version 1.0 
/// Kommentare hinzugefügt (Doxygen).     

namespace basic_structur
{  
  // --------------------------------------
  // ROUTETABLE
  // --------------------------------------
  [Serializable]
  /// @author Marcel Hotopp
  /// @date letzte Aenderung: 10.09.1981
  /// @brief Die Fahrstrassentabelle kann beliebig viele Fahrstrassen aus beliebig vielen Stellwerken enthalten.
  ///        Der Normalfall wäre, dass eine Fahrstrassentabelle alle Fahrstrassen eines Stellwerkes enthält.
  public class RouteTable
  {
    // --------------------------------------
    // VARIABLEN 
    // --------------------------------------
    private string Name;                   //!< Name der RouteTable z.B. Stellwerksname etc.
    private string Version = "";           //!< Version der RouteTable, wird beim speichern gefuellt siehe -> Version.cs
    private string SAPNumber = "";         //!< SAP Kennung (A6Z-Nr) der RouteTable
    private string InputSource = "";       //!< EingabeQuelle aus dem die RouteTable eingelesen/erstellt wurde
    private string InputFileName=null;     //!< Dateiname der Quelle aus dem die RouteTable eingelesen wurde (falls vorhanden)
    private string InputFilePath=null;     //!< Pfad der Quelldatei aus dem die RouteTable eingelesen wurde (falls vorhanden)
    private string CreationTime=null;      //!< Uhrzeit um die die RouteTable eingelesen wurde
    private string CreationWorkstation=""; //!< PC von dem die RouteTable erstellt wurde.
    private string Creator="";             //!< Ersteller (UserName) der RouteTable
    private string[] Interlockings=null;   //!< Array aller enthaltender Interlockings in dieser RouteTable
    private string[] Countrys = null;      //!< Array aller enthaltender Countrys in dieser RouteTable
    private string[] Cities = null;        //!< Array aller enthaltender Cities in dieser RouteTable
    private int iNumOfRoutes=0;            //!< Anzahl der in dem Array enthaltenden Routes(Fahrstraßen)
    private int iNumOfInterlockings = 0;   //!< Anzahl der in dem Array enthaltenden Interlockings
    private int iNumOfCountrys = 0;        //!< Anzahl der in dem Array enthaltenden Countrys
    private int iNumOfCities = 0;          //!< Anzahl der in dem Array enthaltenden Cities
    private int NumOfCommands = 0;         //!< Anzahl der Kommandos die im Element enthalten sind.
    private Route[] routes;                //!< Array, Liste von Routes(RouteObjekten)
    private Command[] Commands;            //!< Array von Kommandos, die dieses Element enthaelt
    
    // --------------------------------------
    // KONSTRUKTOR
    // --------------------------------------
    public RouteTable(string name)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("RouteTable (<b>" + name + "</b>) wurde erstellt.", "RouteTable", "Konstruktor", 1);
      // DEBUG-AUSGABE \\

      // Name der RouteTable setzen
      setName(name);
      
      // Version setzen
      Version vObject = new Version();
      setVersion(vObject.getVersion());
      vObject=null;

      // ErstellungsZeit setzen // Datum + Uhzeit
      setCreationTime(System.DateTime.Now.ToString());      

      // Ersteller / Creator setzen
      setCreator(SystemInformation.UserName);

      // Workstation setzen
      setCreationWorkstation();

      // DEBUG-AUSGABE \\
      DebugMode.debug("RouteTable Version (<b>" + getVersion() + "</b>) wurde gesetzt.", "RouteTable", "Konstruktor", 1);
      // DEBUG-AUSGABE \\

      // Speicher fuer 1000 moegliche Routen reservieren
      routes = new Route[1000];  
      
      Interlockings = new string[50];
      Countrys = new string[50];
      Cities = new string[50];
      Commands = new Command[50];
    }

    // --------------------------------------
    // METHODEN
    // --------------------------------------                

    // --------------------------------------        
    // setWorkstation
    // --------------------------------------        
    private void setCreationWorkstation()
    {
      string HostName = System.Net.Dns.GetHostName();
      System.Net.IPHostEntry hostInfo = System.Net.Dns.GetHostByName(HostName);
      string IpAdresse = hostInfo.AddressList[0].ToString();
      this.CreationWorkstation = System.Net.Dns.GetHostName() + " (" + IpAdresse + ")";
    }

    // --------------------------------------        
    // setName
    // --------------------------------------        
    public void setName(string name)
    {
      this.Name = name;
    }

    // --------------------------------------        
    // setSAPNumber
    // --------------------------------------        
    public void setSAPNumber(string sapnr)
    {
      this.SAPNumber = sapnr;
    }

    // --------------------------------------        
    // getSAPNumber
    // --------------------------------------        
    public string getSAPNumber()
    {
      return this.SAPNumber;
    }

    // --------------------------------------        
    // setVersion
    // --------------------------------------
    /// @brief Set Funktion mit der die Version der Basis Struktur gesetzt wird, mit welcher die RouteTable erstellt wurde.<br>
    ///        Diese Funktion ist private und wird nur vom Konstruktor aufgerufen. Ein manuelles Aufrufen ist absichtlich NICHT<br>
    ///        gewollt!
    /// 
    /// @author Marcel Hotopp
    ///
    /// @param vname
    ///        Version der Basis-Struktur (basic_structur), mit welcher die RouteTable erstellt wurde.
    /// 
    /// @return -    
    ///
    /// @see string getVersion()
    /// 
    /// @version 0.1 
    /// Kommentare hinzugefügt (Doxygen).     
    private void setVersion(string vname)
    {
      this.Version = vname;
    }

    // --------------------------------------        
    // getVersion
    // --------------------------------------        
    /// @brief Get Funktion mit der man sich die Version der Basis Struktur zurückgeben lassen kann, mit welcher
    ///        die RouteTable erstellt wurde.
    /// @author Marcel Hotopp
    ///
    /// @param -
    /// 
    /// @return string Version<br>
    ///         Version der Basis-Struktur (basic_structur), mit welcher die RouteTable erstellt wurde.
    ///
    /// @see setVersion(string)
    /// 
    /// @version 0.1 
    /// Kommentare hinzugefügt (Doxygen).         
    public string getVersion()
    {
      return this.Version;
    }

    // --------------------------------------        
    // getWorkstation
    // --------------------------------------        
    public string getCreationWorkstation()
    {
      return this.CreationWorkstation;
    }

    // --------------------------------------        
    // getName
    // --------------------------------------        
    public string getName()
    {
      return this.Name;
    }

    // --------------------------------------        
    // getRoute
    // --------------------------------------        
    public Route getRoute(int iRouteNr)
    {
      return this.routes[iRouteNr];
    }    
    public Route getRoute(string sRouteName)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Route (" + sRouteName + ") in RouteTable wird gesucht.", "RouteTable", "getRoute(string)", 2);
      // DEBUG-AUSGABE \\

      int iNum = this.getNumOfRoutes();
      for (int x = 0; x < iNum; x++)
      {
        if (this.getRoute(x).getName() == sRouteName)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Route (" + sRouteName + ") in RouteTable gefunden und zurueckgegeben.", "RouteTable", "getRoute(string)", 4);
          // DEBUG-AUSGABE \\

          return this.getRoute(x);
        }
      }

      // DEBUG-AUSGABE \\
      DebugMode.debug("&nbsp;&nbsp;Route (" + sRouteName + ") in RouteTable nicht gefunden!", "RouteTable", "getRoute(string)", 5);
      // DEBUG-AUSGABE \\
      return null;
    }

    // --------------------------------------        
    // getRoutes
    // --------------------------------------        
    public Route[] getRoute()
    {
      return this.routes;
    }
    // --------------------------------------        
    // getRoutesByInterlocking
    // --------------------------------------        
    public Route[] getRoutesByInterlocking(string sInterlocking)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Routen mit Interlocking (" + sInterlocking + ") werden gesucht.", "RouteTable", "getRoutesByInterlocking(string)", 2);
      // DEBUG-AUSGABE \\

      int iNumOfRoutes=this.getNumOfRoutes();
      Route[] gefundeneRouten = new Route[iNumOfRoutes];

      if (iNumOfRoutes > 0)
      {
        int y = 0;
        for (int x = 0; x < iNumOfRoutes; x++)
        {
          if (this.routes[x].getInterlocking() == sInterlocking)
          {
            gefundeneRouten[y] = this.routes[x];
            y++;
          }
        }
        if (y > 0)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;(" + y.ToString() + ")Routen zum Interlocking(" + sInterlocking + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByInterlocking(string)", 4);
          // DEBUG-AUSGABE \\

          // Handelt es sich bei der ermittelten Anzahl Routen um eine unterschiedliche Anzahl der gesamt Routen
          // wird nochmals ein neues Array aufgebaut.
          if (y != iNumOfRoutes)
          {
            Route[] rueckgabeRouten = new Route[y];
            for (int z = 0; z < y; z++)
            {
              rueckgabeRouten[z] = gefundeneRouten[z];
            }
            return rueckgabeRouten;
          }

          return gefundeneRouten;
        }
        else
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;keine Routen zum Interlocking(" + sInterlocking + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByInterlocking(string)", 5);
          // DEBUG-AUSGABE \\

          return null;
        }
      }
      else
      {
        // DEBUG-AUSGABE \\
        DebugMode.debug("&nbsp;&nbsp;keine Routen zum Interlocking(" + sInterlocking + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByInterlocking(string)", 5);
        // DEBUG-AUSGABE \\

        return null;
      }
    }

    // --------------------------------------        
    // getRoutesByCountry
    // --------------------------------------        
    public Route[] getRoutesByCountry(string sCountry)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Routen mit Country (" + sCountry + ") werden gesucht.", "RouteTable", "getRoutesByCountry(string)", 2);
      // DEBUG-AUSGABE \\

      int iNumOfRoutes = this.getNumOfRoutes();
      Route[] gefundeneRouten = new Route[iNumOfRoutes];

      if (iNumOfRoutes > 0)
      {
        int y = 0;
        for (int x = 0; x < iNumOfRoutes; x++)
        {
          if (this.routes[x].getCountry() == sCountry)
          {
            gefundeneRouten[y] = this.routes[x];
            y++;
          }
        }
        if (y > 0)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;(" + y.ToString() + ")Routen zum Country(" + sCountry + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByCountry(string)", 4);
          // DEBUG-AUSGABE \\

          // Handelt es sich bei der ermittelten Anzahl Routen um eine unterschiedliche Anzahl der gesamt Routen
          // wird nochmals ein neues Array aufgebaut.
          if (y != iNumOfRoutes)
          {
            Route[] rueckgabeRouten = new Route[y];
            for (int z = 0; z < y; z++)
            {
              rueckgabeRouten[z] = gefundeneRouten[z];
            }
            return rueckgabeRouten;
          }

          return gefundeneRouten;
        }
        else
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;keine Routen zum Country(" + sCountry + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByCountry(string)", 5);
          // DEBUG-AUSGABE \\

          return null;
        }
      }
      else
      {
        // DEBUG-AUSGABE \\
        DebugMode.debug("&nbsp;&nbsp;keine Routen zum Country(" + sCountry + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByCountry(string)", 5);
        // DEBUG-AUSGABE \\

        return null;
      }
    }

    // --------------------------------------        
    // getRoutesByCity
    // --------------------------------------        
    public Route[] getRoutesByCity(string sCity)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Routen mit City (" + sCity + ") werden gesucht.", "RouteTable", "getRoutesByCity(string)", 2);
      // DEBUG-AUSGABE \\

      int iNumOfRoutes = this.getNumOfRoutes();
      Route[] gefundeneRouten = new Route[iNumOfRoutes];

      if (iNumOfRoutes > 0)
      {
        int y = 0;
        for (int x = 0; x < iNumOfRoutes; x++)
        {
          if (this.routes[x].getCity() == sCity)
          {
            gefundeneRouten[y] = this.routes[x];
            y++;
          }
        }
        if (y > 0)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;(" + y.ToString() + ")Routen zum City(" + sCity + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByCity(string)", 4);
          // DEBUG-AUSGABE \\

          // Handelt es sich bei der ermittelten Anzahl Routen um eine unterschiedliche Anzahl der gesamt Routen
          // wird nochmals ein neues Array aufgebaut.
          if (y != iNumOfRoutes)
          {
            Route[] rueckgabeRouten = new Route[y];
            for (int z = 0; z < y; z++)
            {
              rueckgabeRouten[z] = gefundeneRouten[z];
            }
            return rueckgabeRouten;
          }

          return gefundeneRouten;
        }
        else
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;keine Routen zum City(" + sCity + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByCity(string)", 5);
          // DEBUG-AUSGABE \\

          return null;
        }
      }
      else
      {
        // DEBUG-AUSGABE \\
        DebugMode.debug("&nbsp;&nbsp;keine Routen zum City(" + sCity + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByCity(string)", 5);
        // DEBUG-AUSGABE \\

        return null;
      }
    }

    // --------------------------------------        
    // getRoutesByStartSignal
    // --------------------------------------        
    public Route[] getRoutesByStartSignal(string sStartSignal)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Routen mit Startsignal (" + sStartSignal + ") werden gesucht.", "RouteTable", "getRoutesByStartSignal(string)", 2);
      // DEBUG-AUSGABE \\

      int iNumOfRoutes = this.getNumOfRoutes();
      Route[] gefundeneRouten = new Route[iNumOfRoutes];

      if (iNumOfRoutes > 0)
      {
        int y = 0;
        for (int x = 0; x < iNumOfRoutes; x++)
        {
          if (this.routes[x].getStart().getName() == sStartSignal)
          {
            gefundeneRouten[y] = this.routes[x];
            y++;
          }
        }
        if (y > 0)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;(" + y.ToString() + ")Routen zum StartSignal(" + sStartSignal + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByStartSignal(string)", 4);
          // DEBUG-AUSGABE \\

          return gefundeneRouten;
        }
        else
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;keine Routen zum StartSignal(" + sStartSignal + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByStartSignal(string)", 5);
          // DEBUG-AUSGABE \\

          return null;
        }
      }
      else
      {
        // DEBUG-AUSGABE \\
        DebugMode.debug("&nbsp;&nbsp;keine Routen zum StartSignal(" + sStartSignal + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByStartSignal(string)", 5);
        // DEBUG-AUSGABE \\

        return null;
      }
    }

    // --------------------------------------        
    // getRoutesByDestinationSignal
    // --------------------------------------        
    public Route[] getRoutesByDestinationSignal(string sDestinationSignal)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Routen mit Zielsignal (" + sDestinationSignal + ") werden gesucht.", "RouteTable", "getRoutesByDestinationSignal(string)", 2);
      // DEBUG-AUSGABE \\

      int iNumOfRoutes = this.getNumOfRoutes();
      Route[] gefundeneRouten = new Route[iNumOfRoutes];

      if (iNumOfRoutes > 0)
      {
        int y = 0;
        for (int x = 0; x < iNumOfRoutes; x++)
        {
          if (this.routes[x].getDestination().getName() == sDestinationSignal)
          {
            gefundeneRouten[y] = this.routes[x];
            y++;
          }
        }
        if (y > 0)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;(" + y.ToString() + ")Routen zum ZielSignal(" + sDestinationSignal + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByDestinationSignal(string)", 4);
          // DEBUG-AUSGABE \\

          return gefundeneRouten;
        }
        else
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;keine Routen zum ZielSignal(" + sDestinationSignal + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByDestinationSignal(string)", 5);
          // DEBUG-AUSGABE \\

          return null;
        }
      }
      else
      {
        // DEBUG-AUSGABE \\
        DebugMode.debug("&nbsp;&nbsp;keine Routen zum ZielSignal(" + sDestinationSignal + ") wurden gefunden und zurueckgegeben.", "RouteTable", "getRoutesByDestinationSignal(string)", 5);
        // DEBUG-AUSGABE \\

        return null;
      }
    }

    // --------------------------------------        
    // getInterlocking
    // --------------------------------------        
    public string getInterlocking(int iInterlockingNr)
    {
      return this.Interlockings[iInterlockingNr];
    }

    // --------------------------------------        
    // getCountry
    // --------------------------------------        
    public string getCountry(int iCountryNr)
    {
      return this.Countrys[iCountryNr];
    }

    // --------------------------------------        
    // getCity
    // --------------------------------------        
    public string getCity(int iCityNr)
    {
      return this.Cities[iCityNr];
    }

    // --------------------------------------        
    // getInterlockings
    // --------------------------------------        
    public string[] getInterlockings()
    {
      return this.Interlockings;
    }

    // --------------------------------------        
    // getCountrys
    // --------------------------------------        
    public string[] getCountrys()
    {
      return this.Countrys;
    }

    // --------------------------------------        
    // getCities
    // --------------------------------------        
    public string[] getCities()
    {
      return this.Cities;
    }

    // --------------------------------------        
    // addRoute
    // --------------------------------------        
    public void addRoute(Route route)
    {
      for (int i = 0; i <= iNumOfRoutes; i++)
      {
        if (this.routes[i] == null)
        {
          this.routes[i] = route;
          iNumOfRoutes = getNumOfRoutes() + 1;
          if (route.getInterlocking() != "") addInterlocking(route.getInterlocking());
          if (route.getCountry() != "") addCountry(route.getCountry());
          if (route.getCity() != "") addCity(route.getCity());
          break;
        }
      }
    }    

    // --------------------------------------        
    // deleteRoute
    // --------------------------------------        
    public void deleteRoute(string route)
    {
      Route[] newRouteArray = new Route[1000];

      int nr=0;
      for (int i = 0; i < iNumOfRoutes; i++)
      {
        if (this.routes[i].getName() != route)
        {
          newRouteArray[nr] = this.routes[i];
          nr++;
        }
        else
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Route(" + route + ") aus der RouteTable geloescht.", "RouteTable", "deleteRoute(string)", 0);
          // DEBUG-AUSGABE \\
        }
      }
      this.iNumOfRoutes = nr;
      this.routes = newRouteArray;
    }    

    // --------------------------------------        
    // addInterlocking
    // --------------------------------------        
    private void addInterlocking(string interlocking)
    {      
      for (int i = 0; i <= iNumOfInterlockings; i++)
      {
        if (this.Interlockings[i] == interlocking) break;
        if (this.Interlockings[i] == null)
        {
          this.Interlockings[i] = interlocking;
          iNumOfInterlockings = getNumOfInterlockings() + 1;

          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Der RouteTable Interlocking (" + interlocking + ") hinzugefuegt.", "RouteTable", "addInterlocking", 2);
          // DEBUG-AUSGABE \\                

          break;
        }
      }
    }

    // --------------------------------------        
    // addCountry
    // --------------------------------------        
    private void addCountry(string country)
    {
      for (int i = 0; i <= iNumOfCountrys; i++)
      {
        if (this.Countrys[i] == country) break;
        if (this.Countrys[i] == null)
        {
          this.Countrys[i] = country;
          iNumOfCountrys = getNumOfCountrys() + 1;

          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Der RouteTable Country (" + country + ") hinzugefuegt.", "RouteTable", "addCountry", 2);
          // DEBUG-AUSGABE \\                

          break;
        }
      }
    }

    // --------------------------------------        
    // addCity
    // --------------------------------------        
    private void addCity(string city)
    {
      for (int i = 0; i <= iNumOfCities; i++)
      {
        if (this.Cities[i] == city) break;
        if (this.Cities[i] == null)
        {
          this.Cities[i] = city;
          iNumOfCities = getNumOfCities() + 1;

          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Der RouteTable City (" + city + ") hinzugefuegt.", "RouteTable", "addCity", 2);
          // DEBUG-AUSGABE \\                

          break;
        }
      }
    }

    // --------------------------------------        
    // getNumOfRoutes
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen zurueck
    // --------------------------------------        
    public int getNumOfRoutes()
    {
      int i = 0;
      for (; i < iNumOfRoutes; i++)
      {
        if (this.routes[i] == null)
        {
          break;
        }
      }
      return i;
    }

    // --------------------------------------        
    // getNumOfRoutesByInterlocking
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen 
    // fuer ein Stellwerk zurueck.
    // --------------------------------------        
    public int getNumOfRoutesByInterlocking(string interlocking)
    {
      int nr = 0;
      for (int i=0; i < iNumOfRoutes; i++)
      {
        if (this.routes[i] == null) break;
        if (this.routes[i].getInterlocking() == interlocking) nr++;
      }
      return nr;
    }

    // --------------------------------------        
    // getNumOfRoutesByCountry
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen 
    // fuer ein Land zurueck.
    // --------------------------------------        
    public int getNumOfRoutesByCountry(string country)
    {
      int nr = 0;
      for (int i = 0; i < iNumOfCountrys; i++)
      {
        if (this.routes[i] == null) break;
        if (this.routes[i].getCountry() == country) nr++;
      }
      return nr;
    }

    // --------------------------------------        
    // getNumOfRoutesByCity
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen 
    // fuer ein Land zurueck.
    // --------------------------------------        
    public int getNumOfRoutesByCity(string city)
    {
      int nr = 0;
      for (int i = 0; i < iNumOfCities; i++)
      {
        if (this.routes[i] == null) break;
        if (this.routes[i].getCity() == city) nr++;
      }
      return nr;
    }

    // --------------------------------------        
    // getNumOfInterlockings
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Interlockings zurueck
    // --------------------------------------        
    public int getNumOfInterlockings()
    {
      int i = 0;
      for (; i < iNumOfInterlockings; i++)
      {
        if (this.Interlockings[i] == null)
        {
          break;
        }
      }
      return i;
    }

    // --------------------------------------        
    // getNumOfCountrys
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Countrys zurueck
    // --------------------------------------        
    public int getNumOfCountrys()
    {
      int i = 0;
      for (; i < iNumOfCountrys; i++)
      {
        if (this.Countrys[i] == null)
        {
          break;
        }
      }
      return i;
    }

    // --------------------------------------        
    // getNumOfCities
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Cities zurueck
    // --------------------------------------        
    public int getNumOfCities()
    {
      int i = 0;
      for (; i < iNumOfCities; i++)
      {
        if (this.Cities[i] == null)
        {
          break;
        }
      }
      return i;
    }

    // --------------------------------------        
    // setInputSource
    // --------------------------------------        
    public void setInputSource(string sInput)
    {
      this.InputSource = sInput;
    }

    // --------------------------------------        
    // setCreator
    // --------------------------------------        
    public void setCreator(string sCreator)
    {
      this.Creator = sCreator;
    }

    // --------------------------------------        
    // setInputFileName
    // --------------------------------------        
    public void setInputFileName(string sInput)
    {
      this.InputFileName = sInput;
    }

    // --------------------------------------        
    // setInputFilePath
    // --------------------------------------        
    public void setInputFilePath(string sInput)
    {
      this.InputFilePath = sInput;
    }

    // --------------------------------------        
    // setCreationTime
    // --------------------------------------        
    private void setCreationTime(string sInput)
    {
      this.CreationTime = sInput;
    }

    // --------------------------------------        
    // getInputSource
    // --------------------------------------        
    public string getInputSource()
    {
      return this.InputSource;
    }

    // --------------------------------------        
    // getInputFileName
    // --------------------------------------        
    public string getInputFileName()
    {
      return this.InputFileName;
    }

    // --------------------------------------        
    // getInputFilePath
    // --------------------------------------        
    public string getInputFilePath()
    {
      return this.InputFilePath;
    }

    // --------------------------------------        
    // getCreationTime
    // --------------------------------------        
    public string getCreationTime()
    {
      return this.CreationTime;
    }

    // --------------------------------------        
    // getCreator
    // --------------------------------------        
    public string getCreator()
    {
      return this.Creator;
    }    

    // --------------------------------------        
    // load
    // --------------------------------------        
    // lädt ein komplettes RouteTable Object aus einer
    // Datei.
    // --------------------------------------        
    public RouteTable load()
    {
      return this.load("RouteTable.obj", ".\\");
    }
    public RouteTable load(string sDateiname)
    {
      return this.load(sDateiname, ".\\");
    }
    public RouteTable load(string sDateiname, string sPfad)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("RouteTable wird aus Objekt geladen. Dateiname: <i>"+sPfad+sDateiname+"</i>.", "RouteTable", "load", 0);
      // DEBUG-AUSGABE \\

      RouteTable loadedRouteTable=null;
      FileStream fs = new FileStream(sPfad+sDateiname, FileMode.Open);
      BinaryFormatter formatter = new BinaryFormatter();
      try
      {        
        loadedRouteTable = (RouteTable)formatter.Deserialize(fs);
        
        // Version pruefen
        Version vObject = new Version();
        if (vObject.getVersion() != loadedRouteTable.Version)
        {
          Globale_Funktionen.kill("Geladene RouteTable aus Objekt (" + loadedRouteTable.Version + ") != aktuellem Stand BasisStruktur (" + vObject.getVersion() + ").", "RouteTable", "load", 1);
        }
        vObject = null;
      }
      catch (Exception ex)
      {
        Globale_Funktionen.kill("Nicht moeglich RouteTable aus Objekt zu laden!\n[" + ex.Message + "]", "RouteTable", "load", 2);
      }
      fs.Close();

      if (loadedRouteTable != null)
      {
        // DEBUG-AUSGABE \\
        DebugMode.debug("&nbsp;&nbsp;laden erfolgreich. Version: " + loadedRouteTable.getVersion(), "RouteTable", "load", 4);
        // DEBUG-AUSGABE \\
      }
      else
      {
        // DEBUG-AUSGABE \\
        DebugMode.debug("&nbsp;&nbsp;laden <b>NICHT</b> erfolgreich.", "RouteTable", "load", 7);
        // DEBUG-AUSGABE \\
      }

      return loadedRouteTable;
    }

    // --------------------------------------        
    // save
    // --------------------------------------        
    // sichert ein komplettes RouteTable Objeect auf der
    // Festplatte als Datei.
    // --------------------------------------        
    public void save()
    {
      this.save("RouteTable.obj", ".\\");
    }
    public void save(string sDateiname)
    {
      this.save(sDateiname, ".\\");
    }
    public void save(string sDateiname, string sPfad)
    {
      FileStream fs = new FileStream(sPfad+sDateiname, FileMode.Create);
      BinaryFormatter formatter = new BinaryFormatter();
      formatter.Serialize(fs, this);
      fs.Close();
    }

    // --------------------------------------        
    // getNumOfRoutesWithoutErrors
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen ohne Fehler zurueck
    // --------------------------------------        
    public int getNumOfRoutesWithoutErrors()
    {
      int nr = 0;
      for (int i = 0; i < iNumOfRoutes; i++)
      {
        if (this.routes[i] == null) break;
        if (this.routes[i].isRouteOK()) nr++;
      }
      return nr;
    }

    // --------------------------------------        
    // getNumOfRoutesWithErrors
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen mit Fehler zurueck
    // --------------------------------------        
    public int getNumOfRoutesWithErrors()
    {
      int nr = 0;
      for (int i = 0; i < iNumOfRoutes; i++)
      {
        if (this.routes[i] == null) break;
        if (!this.routes[i].isRouteOK()) nr++;
      }
      return nr;
    }

    // --------------------------------------        
    // getNumOfRoutesWithoutErrorsByInterlocking
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen eines Stellwerks ohne Fehler zurueck
    // --------------------------------------        
    public int getNumOfRoutesWithoutErrorsByInterlocking(string interlocking)
    {
      int nr = 0;
      for (int i = 0; i < iNumOfRoutes; i++)
      {
        if (this.routes[i] == null) break;
        if (this.routes[i].isRouteOK() && this.routes[i].getInterlocking() == interlocking) nr++;
      }
      return nr;
    }
    // --------------------------------------        
    // getNumOfRoutesWithErrorsByInterlocking
    // --------------------------------------        
    // Beschreibung: 
    // Gibt die Anzahl der in der RouteTable enthaltenden Routen eines Stellwerks mit Fehler zurueck
    // --------------------------------------        
    public int getNumOfRoutesWithErrorsByInterlocking(string interlocking)
    {
      int nr = 0;
      for (int i = 0; i < iNumOfRoutes; i++)
      {
        if (this.routes[i] == null) break;
        if (!this.routes[i].isRouteOK() && this.routes[i].getInterlocking() == interlocking) nr++;
      }
      return nr;
    }

    // --------------------------------------        
    // getCommand
    // --------------------------------------        
    public Command getCommand(int iCNr)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Command (" + iCNr.ToString() + ") in RouteTable wird gesucht.", "RouteTable", "getCommand(int)", 2);
      // DEBUG-AUSGABE \\

      int iNum = this.getNumOfCommands();
      for (int x = 0; x < iNum; x++)
      {
        if (this.Commands[x].FunctionNr == iCNr)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Command (" + iCNr.ToString() + ") in RouteTable gefunden und zurueckgegeben.", "RouteTable", "getCommand(int)", 4);
          // DEBUG-AUSGABE \\

          return this.Commands[x];
        }
      }

      // DEBUG-AUSGABE \\
      DebugMode.debug("&nbsp;&nbsp;Command (" + iCNr.ToString() + ") in RouteTable nicht gefunden!", "RouteTable", "getCommand(int)", 5);
      // DEBUG-AUSGABE \\
      return null;
    }
    public Command getCommand(string sLongtext)
    {
      // DEBUG-AUSGABE \\
      DebugMode.debug("Command (" + sLongtext + ") in RouteTable wird gesucht.", "RouteTable", "getCommand(string)", 2);
      // DEBUG-AUSGABE \\

      int iNum = this.getNumOfCommands();
      for (int x = 0; x < iNum; x++)
      {
        if (this.Commands[x].LongText == sLongtext)
        {
          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Command (" + sLongtext + ") in RouteTable gefunden und zurueckgegeben.", "RouteTable", "getCommand(string)", 4);
          // DEBUG-AUSGABE \\

          return this.Commands[x];
        }
      }

      // DEBUG-AUSGABE \\
      DebugMode.debug("&nbsp;&nbsp;Command (" + sLongtext + ") in RouteTable nicht gefunden!", "RouteTable", "getCommand(string)", 5);
      // DEBUG-AUSGABE \\
      return null;
    }


    // --------------------------------------        
    // getNumOfCommands
    // --------------------------------------        
    public int getNumOfCommands()
    {
      int i = 0;
      for (; i < NumOfCommands; i++)
      {
        if (this.Commands[i] == null)
        {
          break;
        }
      }
      return i;
    }

    // --------------------------------------        
    // addCommand
    // --------------------------------------        
    public void addCommand(Command command)
    {
      for (int i = 0; i <= NumOfCommands; i++)
      {
        if (this.Commands[i] != null)
        {
          if (this.Commands[i].FunctionNr == command.FunctionNr) break;
        }
        if (this.Commands[i] == null)
        {
          this.Commands[i] = command;
          NumOfCommands = getNumOfCommands() + 1;

          // DEBUG-AUSGABE \\
          DebugMode.debug("&nbsp;&nbsp;Dem RouteTable(" + this.getName() + ") Command(" + command.Name + ") hinzugefuegt.", "RouteTable", "addCommand(Command)", 2);
          // DEBUG-AUSGABE \\                

          break;
        }
      }
    }

    // --------------------------------------        
    // addRoutes
    // --------------------------------------        
    public void addRoutes(Route[] routes)
    {
      if (routes != null)
      {
        for (int nr = 0; ; nr++)
        {
          if (routes[nr] != null)
          {
            for (int i = 0; i <= iNumOfRoutes; i++)
            {
              if (this.routes[i] == null)
              {
                this.routes[i] = routes[nr];
                iNumOfRoutes = getNumOfRoutes() + 1;
                if (routes[nr].getInterlocking() != "") addInterlocking(routes[nr].getInterlocking());
                if (routes[nr].getCountry() != "") addCountry(routes[nr].getCountry());
                if (routes[nr].getCity() != "") addCity(routes[nr].getCity());
                break;
              }
            }
          }
          else
          {
            break;
          }
        }
      }
    }

            
  }   
}



