first version of completed bus xml reader

VectoCommon/VectoCommon/InputData/DeclarationInputData.cs

@@ -755,9 +755,9 @@ namespace TUGraz.VectoCommon.InputData
 	{
 		int SystemConfiguration { get; }
 
-		ACCompressorType CompressorType { get; }
+		ICompressorType CompressorType { get; }
 
-		string AuxHeaterPower { get; }
+		int AuxHeaterPower { get; }
 
 		bool DoubleGlasing { get; }
 
@@ -770,6 +770,12 @@ namespace TUGraz.VectoCommon.InputData
 		bool EngineWasteGasHeatExchanger { get; }
 
 		bool SeparateAirDistributionDucts { get; }
+	}
 
+	public interface ICompressorType
+	{
+		string DriverAC { get; }
+		string PassengerAC { get; }
 	}
+
 }

VectoCommon/VectoCommon/Resources/XMLNames.Designer.cs

@@ -402,6 +402,213 @@ namespace TUGraz.VectoCommon.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to AdjustableAuxiliaryHeater.
+        /// </summary>
+        public static string Bus_AdjustableAuxiliaryHeater {
+            get {
+                return ResourceManager.GetString("Bus_AdjustableAuxiliaryHeater", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to AlternatorTechnology.
+        /// </summary>
+        public static string Bus_AlternatorTechnology {
+            get {
+                return ResourceManager.GetString("Bus_AlternatorTechnology", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to AuxiliaryHeaterPower.
+        /// </summary>
+        public static string Bus_AuxiliaryHeaterPower {
+            get {
+                return ResourceManager.GetString("Bus_AuxiliaryHeaterPower", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Brakelights.
+        /// </summary>
+        public static string Bus_Brakelights {
+            get {
+                return ResourceManager.GetString("Bus_Brakelights", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to CompressorType.
+        /// </summary>
+        public static string Bus_CompressorType {
+            get {
+                return ResourceManager.GetString("Bus_CompressorType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Dayrunninglights.
+        /// </summary>
+        public static string Bus_Dayrunninglights {
+            get {
+                return ResourceManager.GetString("Bus_Dayrunninglights", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DoorDriveTechnology.
+        /// </summary>
+        public static string Bus_DoorDriveTechnology {
+            get {
+                return ResourceManager.GetString("Bus_DoorDriveTechnology", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DoubleGlasing.
+        /// </summary>
+        public static string Bus_DoubleGlasing {
+            get {
+                return ResourceManager.GetString("Bus_DoubleGlasing", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DriverAC.
+        /// </summary>
+        public static string Bus_DriverAC {
+            get {
+                return ResourceManager.GetString("Bus_DriverAC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to EntranceHeight.
+        /// </summary>
+        public static string Bus_EntranceHeight {
+            get {
+                return ResourceManager.GetString("Bus_EntranceHeight", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Headlights.
+        /// </summary>
+        public static string Bus_Headlights {
+            get {
+                return ResourceManager.GetString("Bus_Headlights", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to HeatPump.
+        /// </summary>
+        public static string Bus_HeatPump {
+            get {
+                return ResourceManager.GetString("Bus_HeatPump", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to HeightIntegratedBody.
+        /// </summary>
+        public static string Bus_HeighIntegratedBody {
+            get {
+                return ResourceManager.GetString("Bus_HeighIntegratedBody", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Interiorlights.
+        /// </summary>
+        public static string Bus_Interiorlights {
+            get {
+                return ResourceManager.GetString("Bus_Interiorlights", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LowEntry.
+        /// </summary>
+        public static string Bus_LowEntry {
+            get {
+                return ResourceManager.GetString("Bus_LowEntry", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LowerDeck.
+        /// </summary>
+        public static string Bus_LowerDeck {
+            get {
+                return ResourceManager.GetString("Bus_LowerDeck", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to PassengerAC.
+        /// </summary>
+        public static string Bus_PassengerAC {
+            get {
+                return ResourceManager.GetString("Bus_PassengerAC", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Positionlights.
+        /// </summary>
+        public static string Bus_Positionlights {
+            get {
+                return ResourceManager.GetString("Bus_Positionlights", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SeparateAirDistributionDucts.
+        /// </summary>
+        public static string Bus_SeparateAirDistributionDucts {
+            get {
+                return ResourceManager.GetString("Bus_SeparateAirDistributionDucts", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SystemConfiguration.
+        /// </summary>
+        public static string Bus_SystemConfiguration {
+            get {
+                return ResourceManager.GetString("Bus_SystemConfiguration", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to UpperDeck.
+        /// </summary>
+        public static string Bus_UpperDeck {
+            get {
+                return ResourceManager.GetString("Bus_UpperDeck", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to VehicleLength.
+        /// </summary>
+        public static string Bus_VehicleLength {
+            get {
+                return ResourceManager.GetString("Bus_VehicleLength", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to VehicleWidth.
+        /// </summary>
+        public static string Bus_VehicleWidth {
+            get {
+                return ResourceManager.GetString("Bus_VehicleWidth", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to AirDrag.
         /// </summary>
@@ -1599,6 +1806,15 @@ namespace TUGraz.VectoCommon.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to ManufacturerAddressCompletedVehicle.
+        /// </summary>
+        public static string ManufacturerAddressCompletedVehicle {
+            get {
+                return ResourceManager.GetString("ManufacturerAddressCompletedVehicle", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to ManufacturerAddressPrimaryVehicle.
         /// </summary>
@@ -1608,6 +1824,15 @@ namespace TUGraz.VectoCommon.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to ManufacturerCompletedVehicle.
+        /// </summary>
+        public static string ManufacturerCompletedVehicle {
+            get {
+                return ResourceManager.GetString("ManufacturerCompletedVehicle", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to ManufacturerPrimaryVehicle.
         /// </summary>
@@ -3066,6 +3291,15 @@ namespace TUGraz.VectoCommon.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to RegisteredClass.
+        /// </summary>
+        public static string Vehicle_RegisteredClass {
+            get {
+                return ResourceManager.GetString("Vehicle_RegisteredClass", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to RetarderRatio.
         /// </summary>
@@ -3147,6 +3381,15 @@ namespace TUGraz.VectoCommon.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to VehicleCode.
+        /// </summary>
+        public static string Vehicle_VehicleCode {
+            get {
+                return ResourceManager.GetString("Vehicle_VehicleCode", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to VIN.
         /// </summary>

VectoCommon/VectoCommon/Resources/XMLNames.resx

@@ -1161,4 +1161,85 @@
   <data name="VectoPrimaryVehicleReport" xml:space="preserve">
     <value>VectoOutputPrimaryVehicle</value>
   </data>
+  <data name="ManufacturerCompletedVehicle" xml:space="preserve">
+    <value>ManufacturerCompletedVehicle</value>
+  </data>
+  <data name="ManufacturerAddressCompletedVehicle" xml:space="preserve">
+    <value>ManufacturerAddressCompletedVehicle</value>
+  </data>
+  <data name="Vehicle_RegisteredClass" xml:space="preserve">
+    <value>RegisteredClass</value>
+  </data>
+  <data name="Vehicle_VehicleCode" xml:space="preserve">
+    <value>VehicleCode</value>
+  </data>
+  <data name="Bus_LowEntry" xml:space="preserve">
+    <value>LowEntry</value>
+  </data>
+  <data name="Bus_HeighIntegratedBody" xml:space="preserve">
+    <value>HeightIntegratedBody</value>
+  </data>
+  <data name="Bus_VehicleLength" xml:space="preserve">
+    <value>VehicleLength</value>
+  </data>
+  <data name="Bus_VehicleWidth" xml:space="preserve">
+    <value>VehicleWidth</value>
+  </data>
+  <data name="Bus_EntranceHeight" xml:space="preserve">
+    <value>EntranceHeight</value>
+  </data>
+  <data name="Bus_DoorDriveTechnology" xml:space="preserve">
+    <value>DoorDriveTechnology</value>
+  </data>
+  <data name="Bus_LowerDeck" xml:space="preserve">
+    <value>LowerDeck</value>
+  </data>
+  <data name="Bus_UpperDeck" xml:space="preserve">
+    <value>UpperDeck</value>
+  </data>
+  <data name="Bus_Dayrunninglights" xml:space="preserve">
+    <value>Dayrunninglights</value>
+  </data>
+  <data name="Bus_Headlights" xml:space="preserve">
+    <value>Headlights</value>
+  </data>
+  <data name="Bus_Positionlights" xml:space="preserve">
+    <value>Positionlights</value>
+  </data>
+  <data name="Bus_Brakelights" xml:space="preserve">
+    <value>Brakelights</value>
+  </data>
+  <data name="Bus_Interiorlights" xml:space="preserve">
+    <value>Interiorlights</value>
+  </data>
+  <data name="Bus_AlternatorTechnology" xml:space="preserve">
+    <value>AlternatorTechnology</value>
+  </data>
+  <data name="Bus_SystemConfiguration" xml:space="preserve">
+    <value>SystemConfiguration</value>
+  </data>
+  <data name="Bus_AuxiliaryHeaterPower" xml:space="preserve">
+    <value>AuxiliaryHeaterPower</value>
+  </data>
+  <data name="Bus_DoubleGlasing" xml:space="preserve">
+    <value>DoubleGlasing</value>
+  </data>
+  <data name="Bus_HeatPump" xml:space="preserve">
+    <value>HeatPump</value>
+  </data>
+  <data name="Bus_AdjustableAuxiliaryHeater" xml:space="preserve">
+    <value>AdjustableAuxiliaryHeater</value>
+  </data>
+  <data name="Bus_SeparateAirDistributionDucts" xml:space="preserve">
+    <value>SeparateAirDistributionDucts</value>
+  </data>
+  <data name="Bus_CompressorType" xml:space="preserve">
+    <value>CompressorType</value>
+  </data>
+  <data name="Bus_DriverAC" xml:space="preserve">
+    <value>DriverAC</value>
+  </data>
+  <data name="Bus_PassengerAC" xml:space="preserve">
+    <value>PassengerAC</value>
+  </data>
 </root>
\ No newline at end of file

VectoCore/VectoCore/InputData/FileIO/JSON/JSONVehicleData.cs

@@ -176,8 +176,8 @@ namespace TUGraz.VectoCore.InputData.FileIO.JSON
 		#region Implementation of IHVACBusAuxiliariesDeclarationData
 
 		public virtual int SystemConfiguration { get; set; }
-		public virtual ACCompressorType CompressorType { get { return ACCompressorType.Unknown; } }
-		public virtual string AuxHeaterPower { get { return null; } }
+		public virtual ICompressorType CompressorType { get { return null; } }
+		public virtual int  AuxHeaterPower { get; set; }
 		public virtual bool DoubleGlasing { get { return false; } }
 		public virtual bool HeatPump { get { return false; } }
 		public virtual bool AdjustableCoolantThermostat { get { return Body["Aux"]?["HVAC"]?.GetEx<bool>("AdjustableCoolantThermostat") ?? false; } }

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/XMLDeclarationBusAuxiliariesDataProvider.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Xml;
 using System.Xml.Linq;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Resources;
+using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.InputData.FileIO.XML.Common;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Interfaces;
+using TUGraz.VectoCore.InputData.Impl;
 using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider {
@@ -42,4 +45,87 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider {
 
 		#endregion
 	}
+
+	public class XMLDeclarationCompleteBusAuxiliariesDataProviderV26 : AbstractXMLType, IXMLBusAuxiliariesDeclarationData
+	{
+		public static XNamespace NAMESPACE_URI = XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V26;
+
+		public const string XSD_TYPE = "CompletedVehicleAuxiliaryDataDeclarationType";
+
+		public static readonly string QUALIFIED_XSD_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_TYPE);
+
+		public XMLDeclarationCompleteBusAuxiliariesDataProviderV26(
+			IXMLDeclarationVehicleData vehicle, XmlNode componentNode, string sourceFile) : base(componentNode) { }
+
+		#region Implementation of IBusAuxiliariesDeclarationData
+
+		public XmlNode XMLSource { get { return BaseNode; } }
+
+		public string FanTechnology { get { return null; } }
+
+		public IList<string> SteeringPumpTechnology { get { return null; } }
+
+
+		public IElectricSupplyDeclarationData ElectricSupply
+		{
+			get
+			{
+				var alternators = GetNodes(XMLNames.Bus_AlternatorTechnology);
+
+				if (alternators.Count > 0) {
+					var currentAlternators = new List<IAlternatorDeclarationInputData>();
+					for (int i = 0; i < alternators.Count; i++) {
+						var technology =  alternators[i]?.InnerText;
+						var ratio = alternators[i]?.Attributes?["ratio"].Value.ToDouble();
+						if(ratio == null)
+							continue;
+						currentAlternators.Add(new AlternatorInputData(technology, (double)ratio ));
+					}
+
+					return new ElectricSupplyDeclarationData {Alternators = currentAlternators};
+				}
+
+				return null;
+			}
+		}
+
+		public IElectricConsumersDeclarationData ElectricConsumers
+		{
+			get
+			{
+				return new ElectricConsumersDeclarationData
+				{
+					DayrunninglightsLED = GetBool(XMLNames.Bus_Dayrunninglights),
+					HeadlightsLED =  GetBool(XMLNames.Bus_Headlights),
+					PositionlightsLED = GetBool(XMLNames.Bus_Positionlights),
+					BrakelightsLED = GetBool(XMLNames.Bus_Brakelights),
+					InteriorLightsLED = GetBool(XMLNames.Bus_Interiorlights)
+				};
+			}
+		}
+
+		public IPneumaticSupplyDeclarationData PneumaticSupply { get { return null; } }
+	
+		public IPneumaticConsumersDeclarationData PneumaticConsumers { get { return null;} }
+
+		public IHVACBusAuxiliariesDeclarationData HVACAux
+		{
+			get
+			{
+				var hvac = new HVACBusAuxiliariesDeclarationData
+				{
+					SystemConfiguration = XmlConvert.ToInt32(GetString(XMLNames.Bus_SystemConfiguration)),
+					CompressorType = new CompressorType( GetString(XMLNames.Bus_DriverAC), GetString(XMLNames.Bus_PassengerAC)),
+					AuxHeaterPower = XmlConvert.ToInt32(GetString(XMLNames.Bus_AuxiliaryHeaterPower)),
+					DoubleGlasing = GetBool(XMLNames.Bus_DoubleGlasing),
+					HeatPump = GetBool(XMLNames.Bus_HeatPump),
+					AdjustableAuxiliaryHeater = GetBool(XMLNames.Bus_AdjustableAuxiliaryHeater),
+					SeparateAirDistributionDucts = GetBool(XMLNames.Bus_SeparateAirDistributionDucts)
+				};
+				return hvac;
+			}
+		}
+
+		#endregion
+	}
 }
\ No newline at end of file

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/XMLDeclarationComponentsDataProvider.cs

-using System.Xml;
+using System;
+using System.Xml;
 using System.Xml.Linq;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Interfaces;
@@ -150,6 +151,42 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 		{ }
 
 
+		IAuxiliariesDeclarationInputData IVehicleComponentsDeclaration.AuxiliaryInputData
+		{
+			get { return null; }
+		}
+
+		public override IBusAuxiliariesDeclarationData BusAuxiliaries { get { return _busAuxiliaries ?? (_busAuxiliaries = ComponentReader.BusAuxiliariesInputData); } }
+
+		protected override XNamespace SchemaNamespace
+		{
+			get { return NAMESPACE_URI; }
+		}
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+
+	public class XMLDeclarationCompleteBusComponentsDataProviderV26 : XMLDeclarationComponentsDataProviderV10, IXMLVehicleComponentsDeclaration
+	{
+		public new static readonly XNamespace NAMESPACE_URI = XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V26;
+
+		public new const string XSD_TYPE = "CompletedVehicleComponentsDeclarationType";
+
+		public new static readonly string QUALIFIED_XSD_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_TYPE);
+
+		private IBusAuxiliariesDeclarationData _busAuxiliaries;
+
+		public XMLDeclarationCompleteBusComponentsDataProviderV26(
+			IXMLDeclarationVehicleData vehicle, XmlNode componentNode, string sourceFile) : base(
+			vehicle, componentNode, sourceFile)
+		{ }
+
+		IGearboxDeclarationInputData IVehicleComponentsDeclaration.GearboxInputData
+		{
+			get { return null; }
+		}
+		
 		IAuxiliariesDeclarationInputData IVehicleComponentsDeclaration.AuxiliaryInputData
 		{
 			get { return null; }

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/XMLDeclarationVehicleDataProvider.cs

@@ -38,6 +38,7 @@ using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Resources;
 using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.FileIO.XML.Common;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Interfaces;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader;
 using TUGraz.VectoCore.InputData.Impl;
@@ -633,5 +634,94 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 		#endregion
 	}
 
-	
+
+	public class XMLDeclarationCompletedBusDataProviderV26 : XMLDeclarationVehicleDataProviderV20
+	{
+		public new static readonly XNamespace NAMESPACE_URI = XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V26;
+
+		public new const string XSD_TYPE = "CompletedVehicleDeclarationType";
+
+		public new static readonly string QUALIFIED_XSD_TYPE =
+			XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_TYPE);
+
+		public XMLDeclarationCompletedBusDataProviderV26(
+			IXMLDeclarationJobInputData jobData, XmlNode xmlNode, string sourceFile) : base(jobData, xmlNode, sourceFile)
+		{
+			SourceType = DataSourceType.XMLEmbedded;
+		}
+
+
+		#region Overrides of AbstractCommonComponentType
+
+		public override string Manufacturer { get { return GetString(XMLNames.ManufacturerCompletedVehicle); } }
+
+		public override string ManufacturerAddress { get { return GetString(XMLNames.ManufacturerAddressCompletedVehicle); } }
+
+		#endregion
+
+
+		#region Overrides of XMLDeclarationVehicleDataProviderV10
+
+		public override string RegisteredClass { get { return GetString(XMLNames.Vehicle_RegisteredClass); } }
+
+		public override VehicleCode VehicleCode { get { return GetString(XMLNames.Vehicle_VehicleCode).ParseEnum<VehicleCode>(); } }
+
+		//TechnicalPermissibleMaximumLadenMass
+		public override Kilogram GrossVehicleMassRating { get { return GetDouble(XMLNames.TPMLM).SI<Kilogram>(); } }
+
+		public override TankSystem? TankSystem
+		{
+			get
+			{
+				return GetString(XMLNames.Vehicle_NgTankSystem).ParseEnum<TankSystem>();
+			}
+		}
+
+		public override int NumberOfPassengersLowerDeck
+		{
+			get
+			{
+				var node = GetNode(XMLNames.Bus_LowerDeck);
+				return XmlConvert.ToInt32(node.InnerText);
+			}
+		}
+
+		public override int NuberOfPassengersUpperDeck
+		{
+			get
+			{
+				var node = GetNode(XMLNames.Bus_UpperDeck);
+				return XmlConvert.ToInt32(node.InnerText);
+			}
+		}
+
+		//HeightIntegratedBody
+		public override Meter Height { get { return GetDouble(XMLNames.Bus_HeighIntegratedBody).SI<Meter>(); }}
+
+		//VehicleLength
+		public override Meter Length { get { return GetDouble(XMLNames.Bus_VehicleLength).SI<Meter>(); } }
+
+		//VehicleWidth
+		public override Meter Width { get { return GetDouble(XMLNames.Bus_VehicleWidth).SI<Meter>(); } }
+
+		#endregion
+
+		public bool LowEntry { get { return GetBool(XMLNames.Bus_LowEntry); } }
+
+		public Meter EntranceHeight { get { return GetDouble(XMLNames.Bus_EntranceHeight).SI<Meter>(); } }
+
+		public string DoorDriveTechnology { get { return GetString(XMLNames.Bus_DoorDriveTechnology); } }
+
+
+		#region Overrides of AbstractXMLResource
+
+		protected override XNamespace SchemaNamespace
+		{
+			get { return NAMESPACE_URI; }
+		}
+
+		protected override DataSourceType SourceType { get; }
+
+		#endregion
+	}
 }

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/NinjectModules/XMLDeclarationInputDataV26InjectModule.cs

@@ -15,15 +15,28 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.NinjectModules {
 			Bind<IXMLDeclarationVehicleData>().To<XMLDeclarationPrimaryBusVehicleDataProviderV26>()
 												.Named(XMLDeclarationPrimaryBusVehicleDataProviderV26.QUALIFIED_XSD_TYPE);
 
+			Bind<IXMLDeclarationVehicleData>().To<XMLDeclarationCompletedBusDataProviderV26>()
+												.Named(XMLDeclarationCompletedBusDataProviderV26.QUALIFIED_XSD_TYPE);
+
 
 			Bind<IXMLVehicleComponentsDeclaration>().To<XMLDeclarationPrimaryBusComponentsDataProviderV26>()
 													.Named(XMLDeclarationPrimaryBusComponentsDataProviderV26.QUALIFIED_XSD_TYPE);
 
+			Bind<IXMLVehicleComponentsDeclaration>().To<XMLDeclarationCompleteBusComponentsDataProviderV26>()
+													.Named(XMLDeclarationCompleteBusComponentsDataProviderV26.QUALIFIED_XSD_TYPE);
+
+
 			Bind<IXMLBusAuxiliariesDeclarationData>().To<XMLDeclarationBusAuxiliariesDataProviderV26>()
 													.Named(XMLDeclarationBusAuxiliariesDataProviderV26.QUALIFIED_XSD_TYPE);
 
+			Bind<IXMLBusAuxiliariesDeclarationData>().To<XMLDeclarationCompleteBusAuxiliariesDataProviderV26>()
+													.Named(XMLDeclarationCompleteBusAuxiliariesDataProviderV26.QUALIFIED_XSD_TYPE);
+
+
 			Bind<IXMLComponentReader>().To<XMLComponentReaderV26>().Named(XMLComponentReaderV26.QUALIFIED_XSD_TYPE);
 
+			Bind<IXMLComponentReader>().To<XMLComponentReaderV26>().Named(XMLComponentReaderV26.QUALIFIED_COMPLETE_XSD_TYPE);
+
 		}
 
 		#endregion

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Reader/Impl/XMLComponentReader.cs

@@ -295,9 +295,14 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader.Impl
 	public class XMLComponentReaderV26 : XMLComponentReaderV20
 	{
 		public new static readonly XNamespace NAMESPACE_URI = XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V26;
+
 		public new const string XSD_TYPE = "PrimaryVehicleComponentsDeclarationType";
 		public new static readonly string QUALIFIED_XSD_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_TYPE);
 
+		public const string COMPLETE_XSD_TYPE = "CompletedVehicleComponentsDeclarationType";
+		public static readonly string QUALIFIED_COMPLETE_XSD_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, COMPLETE_XSD_TYPE);
+		
+
 		protected IBusAuxiliariesDeclarationData _busAuxInputData;
 
 

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Reader/Impl/XMLJobDataReader.cs

@@ -3,6 +3,7 @@ using System.Xml.Linq;
 using Ninject;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Resources;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Factory;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Interfaces;
 using TUGraz.VectoCore.Utils;
@@ -70,10 +71,11 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader.Impl
 		protected override IVehicleDeclarationInputData VehicleCreator(string version, XmlNode vehicleNode, string sourceFile)
 		{
 			var vehicle = Factory.CreateVehicleData(version, JobData, vehicleNode, sourceFile);
-
 			vehicle.ComponentReader = GetReader(vehicle, vehicle.ComponentNode, Factory.CreateComponentReader);
 			vehicle.ADASReader = vehicle.ADASNode == null ? null : GetReader(vehicle, vehicle.ADASNode, Factory.CreateADASReader); //null;
-			vehicle.PTOReader = GetReader(vehicle, vehicle.PTONode, Factory.CreatePTOReader);
+
+			if(!version.EndsWith(XMLDeclarationCompletedBusDataProviderV26.XSD_TYPE))
+				vehicle.PTOReader = GetReader(vehicle, vehicle.PTONode, Factory.CreatePTOReader);
 
 			return vehicle;
 		}

VectoCore/VectoCore/InputData/Impl/InputData.cs

@@ -31,9 +31,11 @@
 
 using System;
 using System.Collections.Generic;
+using TUGraz.VectoCommon.BusAuxiliaries;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.Declaration;
 
 namespace TUGraz.VectoCore.InputData.Impl
 {
@@ -218,4 +220,54 @@ namespace TUGraz.VectoCore.InputData.Impl
 
 		#endregion
 	}
+
+	public class ElectricConsumersDeclarationData : IElectricConsumersDeclarationData
+	{
+		public bool InteriorLightsLED { get; internal set; }
+		public bool DayrunninglightsLED { get; internal set; }
+		public bool PositionlightsLED { get; internal set; }
+		public bool HeadlightsLED { get; internal set; }
+		public bool BrakelightsLED { get; internal set; }
+	}
+
+	public class ElectricSupplyDeclarationData : IElectricSupplyDeclarationData
+	{
+		public IList<IAlternatorDeclarationInputData> Alternators { get; internal set; }
+		public IResultCardDeclarationInputData ResultCards { get; internal set; }
+		public bool SmartElectrics { get; internal set; }
+	}
+
+
+	public class HVACBusAuxiliariesDeclarationData : IHVACBusAuxiliariesDeclarationData
+	{
+		public bool AdjustableAuxiliaryHeater { get; internal set; }
+
+		public bool AdjustableCoolantThermostat { get; internal set; }
+
+		public int AuxHeaterPower { get; internal set; }
+
+		public ICompressorType CompressorType { get; internal set; }
+		
+		public bool DoubleGlasing { get; internal set; }
+
+		public bool EngineWasteGasHeatExchanger { get; internal set; }
+
+		public bool HeatPump { get; internal set; }
+
+		public bool SeparateAirDistributionDucts { get; internal set; }
+
+		public int SystemConfiguration { get; internal set; }
+	}
+
+	public class CompressorType : ICompressorType
+	{
+		public string DriverAC { get; }
+		public string PassengerAC { get; }
+		public CompressorType(string driverAC, string passengerAC)
+		{
+			DriverAC = driverAC;
+			PassengerAC = passengerAC;
+		}
+	}
+
 }
\ No newline at end of file

VectoCore/VectoCoreTest/VectoCoreTest.csproj

@@ -207,6 +207,7 @@
     <Compile Include="Utils\MockModalDataContainer.cs" />
     <Compile Include="Utils\DoubleExtensionMethodTest.cs" />
     <Compile Include="Utils\VectoMathTest.cs" />
+    <Compile Include="XML\XMLCompleteBusReaderTest.cs" />
     <Compile Include="XML\XMLDeclarationInputTest.cs" />
     <Compile Include="XML\XMLDeclarationReaderVersionsTest.cs" />
     <Compile Include="XML\XMLEngineeringInputRefTest.cs" />
@@ -3581,6 +3582,8 @@
     <Content Include="TestData\XML\XMLReaderDeclaration\SchemaVersion2.3\vehicle_sampleDualModeDualFuel.xml">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="TestData\XML\XMLReaderDeclaration\SchemaVersion2.6_Buses\example_heavyBus_PIF.xml" />
+    <Content Include="TestData\XML\XMLReaderDeclaration\SchemaVersion2.6_Buses\vecto_vehicle-completed_heavyBus.xml" />
     <Content Include="TestData\XML\XMLReaderDeclaration\SchemaVersion2.6_Buses\vecto_vehicle-primary_heavyBus.xml">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>

VectoCore/VectoCoreTest/XML/XMLCompleteBusReaderTest.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using Ninject;
+using NUnit.Framework;
+using TUGraz.VECTO;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.FileIO.XML;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider;
+
+namespace TUGraz.VectoCore.Tests.XML
+{
+
+	[TestFixture]
+	public class XMLCompleteBusReaderTest
+	{
+		private const string CompleteBusExample =
+			"TestData/XML/XMLReaderDeclaration/SchemaVersion2.6_Buses/vecto_vehicle-completed_heavyBus.xml";
+
+
+
+		protected IXMLInputDataReader xmlInputReader;
+		private IKernel _kernel;
+
+
+		[OneTimeSetUp]
+		public void RunBeforeAnyTests()
+		{
+			Directory.SetCurrentDirectory(TestContext.CurrentContext.TestDirectory);
+
+			_kernel = new StandardKernel(new VectoNinjectModule());
+			xmlInputReader = _kernel.Get<IXMLInputDataReader>();
+		}
+
+
+		[TestCase]
+		public void TestCompleteBusVehicleData()
+		{
+			var reader = XmlReader.Create(CompleteBusExample);
+
+			var inputDataProvider = xmlInputReader.CreateDeclaration(reader);
+			var vehicle = inputDataProvider.JobInputData.Vehicle;
+
+			Assert.IsNotNull(vehicle);
+			Assert.AreEqual("Some Manufacturer", vehicle.Manufacturer);
+			Assert.AreEqual("Infinite Loop 1", vehicle.ManufacturerAddress);
+			Assert.AreEqual("Sample Bus Model", vehicle.Model);
+			Assert.AreEqual("VEH-1234567890", vehicle.VIN);
+			Assert.AreEqual(DateTime.Parse("2020-01-09T11:00:00Z").ToUniversalTime(), vehicle.Date);
+			Assert.IsTrue(vehicle.LegislativeClass == LegislativeClass.N2);
+			Assert.AreEqual("II+III", vehicle.RegisteredClass);
+			Assert.IsTrue(vehicle.VehicleCode == VehicleCode.CD);
+			Assert.AreEqual(8300, vehicle.CurbMassChassis.Value());
+			Assert.AreEqual(15400, vehicle.GrossVehicleMassRating.Value());//TechnicalPermissibleMaximumLadenMass ?!?
+			Assert.That(() => vehicle.TankSystem, Throws.InstanceOf<VectoException>());
+			Assert.AreEqual(50, vehicle.NumberOfPassengersLowerDeck);
+			Assert.AreEqual(0, vehicle.NuberOfPassengersUpperDeck);
+			Assert.IsTrue(((XMLDeclarationCompletedBusDataProviderV26)vehicle).LowEntry);
+			Assert.AreEqual(2.700, vehicle.Height.Value());
+			Assert.AreEqual(11.830, vehicle.Length.Value());
+			Assert.AreEqual(2.550, vehicle.Width.Value());
+			Assert.AreEqual(0.120, ((XMLDeclarationCompletedBusDataProviderV26)vehicle).EntranceHeight.Value());
+			Assert.AreEqual("pneumatic", ((XMLDeclarationCompletedBusDataProviderV26)vehicle).DoorDriveTechnology);
+	
+			var components = inputDataProvider.JobInputData.Vehicle.Components;
+			Assert.IsNotNull(components);
+			
+			var airDrag = components.AirdragInputData;
+
+			Assert.AreEqual("Generic Manufacturer", airDrag.Manufacturer);
+			Assert.AreEqual("Generic Model", airDrag.Model);
+			Assert.AreEqual("e12*0815/8051*2017/05E0000*00", airDrag.CertificationNumber);
+			Assert.AreEqual(DateTime.Parse("2017-03-24T15:00:00Z").ToUniversalTime(), airDrag.Date.ToUniversalTime());
+			Assert.AreEqual("Vecto AirDrag x.y", airDrag.AppVersion);
+			//CdxA ?!?
+			//TransferredCdxA ?!? 
+			Assert.AreEqual(6.34, airDrag.AirDragArea.Value());
+			
+			Assert.AreEqual("#CabinX23h", airDrag.DigestValue.Reference);
+			Assert.AreEqual("urn:vecto:xml:2017:canonicalization", airDrag.DigestValue.CanonicalizationMethods[0]);
+			Assert.AreEqual("http://www.w3.org/2001/10/xml-exc-c14n#", airDrag.DigestValue.CanonicalizationMethods[1]);
+			Assert.AreEqual("http://www.w3.org/2001/04/xmlenc#sha256", airDrag.DigestValue.DigestMethod);
+			Assert.AreEqual("b9SHCfOoVrBxFQ8wwDK32OO+9bd85DuaUdgs6j/29N8=", airDrag.DigestValue.DigestValue);
+
+			var auxiliaries = components.BusAuxiliaries;
+			Assert.IsFalse(auxiliaries.ElectricConsumers.DayrunninglightsLED);
+			Assert.IsFalse(auxiliaries.ElectricConsumers.HeadlightsLED);
+			Assert.IsFalse(auxiliaries.ElectricConsumers.PositionlightsLED);
+			Assert.IsFalse(auxiliaries.ElectricConsumers.BrakelightsLED);
+			Assert.IsFalse(auxiliaries.ElectricConsumers.InteriorLightsLED);
+			
+			var electricSupl = components.BusAuxiliaries.ElectricSupply;
+			Assert.IsNotNull(electricSupl.Alternators);
+			Assert.AreEqual(1, electricSupl.Alternators.Count);
+			Assert.AreEqual(1.000, electricSupl.Alternators.First().Ratio);
+			Assert.AreEqual("Sample Alternator Technology 1", electricSupl.Alternators.First().Technology);
+
+			var havacAux = components.BusAuxiliaries.HVACAux;
+			Assert.IsNotNull(havacAux);
+			Assert.AreEqual(7, havacAux.SystemConfiguration);
+			Assert.AreEqual("sample tech 2", havacAux.CompressorType.DriverAC);
+			Assert.AreEqual("sample tech 1", havacAux.CompressorType.PassengerAC);
+			Assert.AreEqual(0, havacAux.AuxHeaterPower);
+			Assert.IsTrue(havacAux.DoubleGlasing);
+			Assert.IsFalse(havacAux.HeatPump);
+			Assert.IsTrue(havacAux.AdjustableAuxiliaryHeater);
+			Assert.IsTrue(havacAux.SeparateAirDistributionDucts);
+		}
+	}
+}