internal XElement ToXElement()
        {
            XElement parentDataPointReferenceElement = new XElement(NamespaceHelper.GetXName("ParentDataPointReference"));

            //// Export attributes of all implemented interfaces
            parentDataPointReferenceElement.ImportISignableItem(this);

            //// Export all other attributes
            parentDataPointReferenceElement.AddAttribute("seriesID", this.SeriesId);

            //// Export the child elements of the current object
            XElement startValueElement = new XElement(NamespaceHelper.GetXName("StartValue"));

            startValueElement.Add(DynamicValueHelper.XElementFromValue(this.StartValue));
            parentDataPointReferenceElement.Add(startValueElement);

            if (this.EndValue != null)
            {
                XElement endValueElement = new XElement(NamespaceHelper.GetXName("EndValue"));
                endValueElement.Add(DynamicValueHelper.XElementFromValue(this.EndValue));
                parentDataPointReferenceElement.Add(endValueElement);
            }

            return(parentDataPointReferenceElement);
        }
Esempio n. 2
0
        private void SetValueAndThrowOnFailure(dynamic value)
        {
            DynamicValueHelper.EnsureValidDataType(value);

            this.value         = value;
            this.ParameterType = DynamicValueHelper.GetParameterType(this.value);
        }
Esempio n. 3
0
        internal XElement ToXElement()
        {
            XElement individualValueSetElement = new XElement(NamespaceHelper.GetXName("IndividualValueSet"));

            //// Export attributes of all implemented interfaces
            individualValueSetElement.ImportIValueSet(this);

            //// Export the values to child elements
            this.ForEach(v => individualValueSetElement.Add(DynamicValueHelper.XElementFromValue(v)));

            return(individualValueSetElement);
        }
        private void EnsureValueTypesAreAllowedAndMatch(dynamic value1, dynamic value2)
        {
            if (value1 == null)
            {
                throw new ArgumentNullException(nameof(value1));
            }

            if (value2 == null)
            {
                throw new ArgumentNullException(nameof(value2));
            }

            DynamicValueHelper.EnsureValidNumericDataType(value1);
            DynamicValueHelper.EnsureValidNumericDataType(value2);

            if (value1.GetType() != value2.GetType())
            {
                throw new ArgumentException("Types of values do not match.");
            }
        }
Esempio n. 5
0
        internal XElement ToXElement()
        {
            XElement parameterElement = new XElement(NamespaceHelper.GetXName("Parameter"));

            //// Export attributes of all implemented interfaces
            parameterElement.ImportISignableItemWithName(this);

            //// Export all other attributes
            parameterElement.AddAttribute("parameterType", this.ParameterType.GetXmlRepresentation());

            //// Export the child elements of the current object
            parameterElement.Add(DynamicValueHelper.XElementFromValue(this.Value));

            if (this.Unit != null)
            {
                parameterElement.Add(this.Unit.ToXElement());
            }

            return(parameterElement);
        }
        internal XElement ToXElement()
        {
            XElement autoIncrementedValueSetElement = new XElement(NamespaceHelper.GetXName("AutoIncrementedValueSet"));

            //// Export attributes of all implemented interfaces
            autoIncrementedValueSetElement.ImportIValueSet(this);

            //// Export the child elements of the current object
            autoIncrementedValueSetElement.Add(new XElement(NamespaceHelper.GetXName("StartValue"), DynamicValueHelper.XElementFromValue(this.StartValue)));
            autoIncrementedValueSetElement.Add(new XElement(NamespaceHelper.GetXName("Increment"), DynamicValueHelper.XElementFromValue(this.Increment)));

            return(autoIncrementedValueSetElement);
        }