Example #1
0
        protected void Validate(CTime cTime)
        {
            this.ValidateBase((CPrimitive)cTime);

            if (cTime.MinuteValidity != null)
            {
                this.Validate(cTime.MinuteValidity);
                Invariant(cTime.MinuteValidity.value != 1002 || (cTime.SecondValidity.value == 1002 || cTime.SecondValidity.value == 1003),
                    "cTime.MinuteValidity.valueis optional, means DayValidity must be either optional or disallowed.");

                Invariant(cTime.MinuteValidity.value != 1003 || cTime.SecondValidity.value == 1003,
                    "cTime.MinuteValidity is disallowed, implies cTime.SecondValidity must be disallowed.");
            }

            if (cTime.SecondValidity != null)
            {
                this.Validate(cTime.SecondValidity);
                Invariant(cTime.SecondValidity.value != 1002 || (cTime.MillisecondValidity.value == 1002 || cTime.MillisecondValidity.value == 1003),
                    "cTime.SecondValidity is optional, means SecondValidity must be either optional or disallowed.");

                Invariant(cTime.SecondValidity.value != 1003 || cTime.MillisecondValidity.value == 1003,
                  "cTime.SecondValidity is disallowed, implies cTime.MillisecondValidity must be disallowed.");
            }
        }
Example #2
0
        private void WriteXml(CTime cPrimitive)
        {
            if (!string.IsNullOrEmpty(cPrimitive.Pattern))
                writer.WriteElementString("pattern", OpenEhrNamespace, cPrimitive.Pattern);

            if (cPrimitive.TimezoneValidity != null)
                writer.WriteElementString("timezone_validity", OpenEhrNamespace, cPrimitive.TimezoneValidity.Value.ToString());

            if (cPrimitive.Range != null)
                this.WriteXml(cPrimitive.Range);

            if (cPrimitive.AssumedValue != null)
            {
                writer.WriteStartElement(UseOpenEhrPrefix(writer), "assumed_value", OpenEhrNamespace);
                writer.WriteString(cPrimitive.AssumedValue.ToString());
                writer.WriteEndElement();
            }
        }
Example #3
0
        internal static OpenEhr.AM.Archetype.ConstraintModel.Primitive.CPrimitive CPrimitive(string typeName)
        {
            DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName"));

            OpenEhr.AM.Archetype.ConstraintModel.Primitive.CPrimitive cPrimitive = null;
            switch (typeName)
            {
                case "C_BOOLEAN":
                    cPrimitive = new CBoolean();
                    break;
                case "C_DATE":
                    cPrimitive = new CDate();
                    break;
                case "C_DATE_TIME":
                    cPrimitive = new CDateTime();
                    break;
                case "C_DURATION":
                    cPrimitive = new CDuration();
                    break;
                case "C_TIME":
                    cPrimitive = new CTime();
                    break;
                case "C_INTEGER":
                    cPrimitive = new CInteger();
                    break;
                case "C_REAL":
                    cPrimitive = new CReal();
                    break;
                case "C_STRING":
                    cPrimitive = new CString();
                    break;
                default:
                    throw new NotSupportedException("type not supported: " + typeName);
            }

            DesignByContract.Check.Ensure(cPrimitive != null, "cObject must not be null.");

            return cPrimitive;
        }
Example #4
0
        private void ReadXml(CTime cTime)
        {
            reader.ReadStartElement();
            reader.MoveToContent();

            string openEhrNamespace = RmXmlSerializer.OpenEhrNamespace;

            if (reader.LocalName == "pattern")
            {
                cTime.Pattern = reader.ReadElementContentAsString("pattern", openEhrNamespace);
                reader.MoveToContent();
            }

            if (reader.LocalName == "timezone_validity")
            {
                cTime.TimezoneValidity = new ValidityKind(reader.ReadElementContentAsInt("timezone_validity", openEhrNamespace));
                reader.MoveToContent();
            }

            if (reader.LocalName == "range")
            {
                cTime.Range = new Interval<Iso8601Time>();
                this.ReadXml(cTime.Range);
            }

            if (reader.LocalName == "assumed_value")
            {
                cTime.AssumedValue = new AssumedTypes.Iso8601Date(reader.ReadElementContentAsString("assumed_value", openEhrNamespace));
                reader.MoveToContent();
            }

            reader.ReadEndElement();
            reader.MoveToContent();
        }