public void Initialise(XElement xElement, IDocumentAccessor accessor)
        {
            xElement = Persistence.ThisOrSingleChild(XName, xElement);

            var identity = Persistence.Identity.Parse(xElement, accessor);

            SetIdentity(identity);

            var xComponentType = xElement
                .Elements("ComponentType")
                .SingleOrDefault();

            ComponentType.Initialise(xComponentType, accessor);

            var xEngineType = xElement
                .Elements("EngineType")
                .SingleOrDefault();

            EngineType.Initialise(xEngineType, accessor);

            UseNativeEngine = Utilities.Xml.GetAttribute(xElement, "useNativeEngine", false);

            Arguments = Persistence.Arguments
                .Parse(xElement, accessor)
                .ToList();

            Inputs = Persistence.Inputs
                .Parse(xElement, accessor)
                .ToList();

            Outputs = Persistence.Outputs
                .Parse(xElement, accessor)
                .ToList();
        }

        public void Initialise(XElement xElement, IDocumentAccessor accessor)
        {
            xElement = Persistence.ThisOrSingleChild(XName, xElement);

            ISpatialDefinition spatial;
            bool hasZ, hasM;
            ElementType = Persistence.ElementSet.Parse(xElement, accessor, out spatial, out hasZ, out hasM);
            SetSpatial(spatial);
            HasZ = hasZ;
            HasM = hasM;

            string relative = xElement.Value;

            var uri = new Uri(accessor.Uri, relative);

            var selafin = new FileInfo(uri.LocalPath);

            Selafin = new Selafin(selafin);

               var argIdSelafin =  Utilities.Xml.GetAttribute(xElement, "argIdSelafin");

               Arguments = new IArgument[] {
                new ArgumentFile(new Identity(argIdSelafin, "Selafin file"), selafin),
                }.ToList();

            Initialise();
        }

 public XElement Persist(IDocumentAccessor accessor)
 {
     return new XElement(Component.NamespaceOpenMIv2 + "Argument",
         new XAttribute("Key", Key),
         new XAttribute("Value", Value),
         new XAttribute("ReadOnly", ReadOnly));
 }

 public void Indent(IDocumentAccessor document, bool keepEmptyLines)
 {
     if (document == null)
     {
         throw new ArgumentNullException("document");
     }
 }

        public void Reformat(IDocumentAccessor doc, IndentationSettings settings)
        {
            Init();

            while (doc.MoveNext())
                Step(doc, settings);
        }

 public override XElement Persist(IDocumentAccessor accessor)
 {
     return new XElement("Category",
         new XAttribute("type", _value.GetType().ToString()),
         new XAttribute("value", _value.ToString()),
         base.Persist(accessor));
 }

        public Category(XElement xElement, IDocumentAccessor accessor)
            : base(xElement.Elements("Describes").Single(), accessor)
        {
            Utilities.Xml.ValidElement(xElement, "Category");

            Type type = Type.GetType(Utilities.Xml.GetAttribute(xElement, "type"));
            _value = Convert.ChangeType(Utilities.Xml.GetAttribute(xElement, "value"), type);
        }

            public void Initialise(XElement xElement, IDocumentAccessor accessor)
            {
                Contract.Requires(xElement != null, "xElement != null");

                Key = Utilities.Xml.GetAttribute(xElement, "Key");
                Value = Utilities.Xml.GetAttribute(xElement, "Value");
                ReadOnly = Utilities.Xml.GetAttribute(xElement, "ReadOnly", false);
            }

        public override void Initialise(string initialisingXml, IDocumentAccessor accessor)
        {
            base.Initialise(initialisingXml, accessor);

            _caption = ArgumentCaption;

            _timeDelta = (double)Argument(SimpleComponent.GetArgumentIdentity(
                SimpleComponent.ConsumerArgs.TimeDelta)).Value;
        }

        /// <summary>
        /// Simple implementation of interface FluidEarth2.Sdk.Interfaces.IEngine::Initialise()
        /// 
        /// Overide if specific additional functionality required.
        /// </summary>
        /// <param name="initialisingXml">See FluidEarth2.Sdk.BaseEngine</param>
        /// <param name="accessor">See FluidEarth2.Sdk.BaseEngine</param>
        public override void Initialise(string initialisingXml, IDocumentAccessor accessor)
        {
            base.Initialise(initialisingXml, accessor);

            _horizon = new Time(ArgumentTimeHorizon);
            _timeCurrent = _horizon.StampAsModifiedJulianDay;

            if (double.IsNegativeInfinity(_timeCurrent))
                throw new Exception("Time horizon start is unbounded");
        }

		/// <summary>
		/// Performs indentation using the specified document accessor.
		/// </summary>
		/// <param name="document">Object used for accessing the document line-by-line</param>
		/// <param name="keepEmptyLines">Specifies whether empty lines should be kept</param>
		public void Indent(IDocumentAccessor document, bool keepEmptyLines)
		{
			if (document == null)
				throw new ArgumentNullException("document");
			IndentationSettings settings = new IndentationSettings();
			settings.IndentString = this.IndentationString;
			settings.LeaveEmptyLines = keepEmptyLines;
			
			IndentationReformatter r = new IndentationReformatter();
			r.Reformat(document, settings);
		}

        public virtual void Initialise(XElement xElement, IDocumentAccessor accessor)
        {
            xElement = Persistence.ThisOrSingleChild(XName, xElement);

            ISpatialDefinition spatial;
            bool hasZ, hasM;
            ElementType = Persistence.ElementSet.Parse(xElement, accessor, out spatial, out hasZ, out hasM);
            SetSpatial(spatial);
            HasZ = hasZ;
            HasM = hasM;
        }

        public override void Initialise(XElement xElement, IDocumentAccessor accessor)
        {
            xElement = Persistence.ThisOrSingleChild(XName, xElement);

            base.Initialise(xElement, accessor);

            IndexMap = xElement
                .Elements("Indexes")
                .Select(x => Persistence.Values<int>.Parse(x, accessor))
                .ToArray();
        }

        public void Initialise(XElement xElement, IDocumentAccessor accessor)
        {
            xElement = Persistence.ThisOrSingleChild(XName, xElement);

            Identity = Persistence.Identity.Parse(xElement, accessor);
            ValueDefinition = Persistence.ValueDefinition.Parse(xElement, accessor);
            SpatialDefinition = Persistence.SpatialDefinition.Parse(xElement, accessor);
            TimeSet = Persistence.TimeSet.Parse(xElement, accessor);

            Component = null;
            Provider = null;
        }

        /// <summary>
        /// Performs indentation using the specified document accessor.
        /// </summary>
        /// <param name="document">Object used for accessing the document line-by-line</param>
        /// <param name="indentationString">The string used for indentation.</param>
        /// <param name="keepEmptyLines">Specifies whether empty lines should be kept</param>
        private void Indent(IDocumentAccessor document, string indentationString, bool keepEmptyLines)
        {
            if (document == null)
                throw new ArgumentNullException(nameof(document));

            IndentationSettings settings = new IndentationSettings();
            settings.IndentString = indentationString;
            settings.LeaveEmptyLines = keepEmptyLines;

            CSharpIndentationReformatter r = new CSharpIndentationReformatter();
            r.Reformat(document, settings);
        }

		/// <summary>
		///     Performs indentation using the specified document accessor.
		/// </summary>
		/// <param name="document">Object used for accessing the document line-by-line</param>
		/// <param name="keepEmptyLines">Specifies whether empty lines should be kept</param>
		public int Indent(IDocumentAccessor document, bool keepEmptyLines, int caretOffset)
		{
			if (document == null)
				throw new ArgumentNullException("document");
			var settings = new IndentationSettings();
			settings.IndentString = IndentationString;
			settings.LeaveEmptyLines = keepEmptyLines;

			var r = new IndentationReformatter();
			r.Reformat(document, settings);
			return caretOffset;
		}

        public override void Initialise(XElement xElement, IDocumentAccessor accessor)
        {
            xElement = Persistence.ThisOrSingleChild(XName, xElement);

            base.Initialise(xElement, accessor);

            Ids = xElement
                .Elements(Persistence.Identity.XName)
                .Select(i => Persistence.Identity.Parse(i, accessor))
                .ToArray();

            ElementCount = Ids.Length;
        }

 public void Indent(IDocumentAccessor document, bool keepEmptyLines)
 {
     if (document == null)
     {
         throw new ArgumentNullException("document");
     }
     var set = new IndentationSettings
     {
         IndentString = IndentationString,
         LeaveEmptyLines = keepEmptyLines
     };
     var indentationClass = new IndentationClass();
     indentationClass.Reformat(document, set);
 }

        public virtual void Initialise(XElement xElement, IDocumentAccessor accessor)
        {
            xElement = Persistence.ThisOrSingleChild(XName, xElement);

            Identity = Persistence.Identity.Parse(xElement, accessor);
            ValueDefinition = Persistence.ValueDefinition.Parse(xElement, accessor);
            SpatialDefinition = Persistence.SpatialDefinition.Parse(xElement, accessor);
            TimeSet = Persistence.TimeSet.Parse(xElement, accessor);

            Component = null;
            Provider = null;

            _valueSetConverterTime = Persistence.Parse<IValueSetConverterTime>("ValueSetConverterTime", xElement, accessor);
            _valueSetConverterTime.ExchangeItem = this;
        }

        public LinkableComponentOpenMIV1Wrapper(ILinkableComponentVersion1 component1, 
            IDocumentAccessor accessor,
            List<Utilities.Standard1.Argument1> args1)
            : base(new Identity(component1.ComponentID,
                    component1.ModelID + " [OpenMIv1]", component1.ComponentDescription),
                new ExternalType(typeof(LinkableComponentOpenMIV1Wrapper)),
                new ExternalType(typeof(EngineProxy)))
        {
            Description += "\r\nConverted from OpenMI Standard 1";

            DocumentAccessor = accessor;

            var uriPersistence = InitialiseArguments(component1, args1);

            ConstuctComponent(component1, uriPersistence, args1);
        }