public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.Struct)
                        {
                            Ref = new TDDIAssuranceLevel();
                            Ref.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 2
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list52 = iprot.ReadListBegin();
                                for (int _i53 = 0; _i53 < _list52.Count; ++_i53)
                                {
                                    TDDIKeyValueMap _elem54;
                                    _elem54 = new TDDIKeyValueMap();
                                    _elem54.Read(iprot);
                                    KeyValueMaps.Add(_elem54);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list55 = iprot.ReadListBegin();
                                for (int _i56 = 0; _i56 < _list55.Count; ++_i56)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem57;
                                    _elem57 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem57.Read(iprot);
                                    DependabilityRequirements.Add(_elem57);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.String)
                        {
                            FlowType = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.I32)
                        {
                            Direction = (TDDIPortDirection)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                RefinedPorts = new List <TDDIPortRef>();
                                TList _list58 = iprot.ReadListBegin();
                                for (int _i59 = 0; _i59 < _list58.Count; ++_i59)
                                {
                                    TDDIPortRef _elem60;
                                    _elem60 = new TDDIPortRef();
                                    _elem60.Read(iprot);
                                    RefinedPorts.Add(_elem60);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                InterfaceFailures = new List <TDDIAbstractFailureRef>();
                                TList _list61 = iprot.ReadListBegin();
                                for (int _i62 = 0; _i62 < _list61.Count; ++_i62)
                                {
                                    TDDIAbstractFailureRef _elem63;
                                    _elem63 = new TDDIAbstractFailureRef();
                                    _elem63.Read(iprot);
                                    InterfaceFailures.Add(_elem63);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 3
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                bool   isset_FromPort = false;
                bool   isset_ToPort   = false;
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list64 = iprot.ReadListBegin();
                                for (int _i65 = 0; _i65 < _list64.Count; ++_i65)
                                {
                                    TDDIKeyValueMapRef _elem66;
                                    _elem66 = new TDDIKeyValueMapRef();
                                    _elem66.Read(iprot);
                                    KeyValueMaps.Add(_elem66);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list67 = iprot.ReadListBegin();
                                for (int _i68 = 0; _i68 < _list67.Count; ++_i68)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem69;
                                    _elem69 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem69.Read(iprot);
                                    DependabilityRequirements.Add(_elem69);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Struct)
                        {
                            FromPort = new TDDIPort();
                            FromPort.Read(iprot);
                            isset_FromPort = true;
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Struct)
                        {
                            ToPort = new TDDIPort();
                            ToPort.Read(iprot);
                            isset_ToPort = true;
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
                if (!isset_FromPort)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA, "required field FromPort not set");
                }
                if (!isset_ToPort)
                {
                    throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ToPort not set");
                }
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list416 = iprot.ReadListBegin();
                                for (int _i417 = 0; _i417 < _list416.Count; ++_i417)
                                {
                                    TDDIKeyValueMapRef _elem418;
                                    _elem418 = new TDDIKeyValueMapRef();
                                    _elem418.Read(iprot);
                                    KeyValueMaps.Add(_elem418);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceLevels = new List <TDDIAssuranceLevel>();
                                TList _list419 = iprot.ReadListBegin();
                                for (int _i420 = 0; _i420 < _list419.Count; ++_i420)
                                {
                                    TDDIAssuranceLevel _elem421;
                                    _elem421 = new TDDIAssuranceLevel();
                                    _elem421.Read(iprot);
                                    AssuranceLevels.Add(_elem421);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 5
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list84 = iprot.ReadListBegin();
                                for (int _i85 = 0; _i85 < _list84.Count; ++_i85)
                                {
                                    TDDIKeyValueMap _elem86;
                                    _elem86 = new TDDIKeyValueMap();
                                    _elem86.Read(iprot);
                                    KeyValueMaps.Add(_elem86);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list87 = iprot.ReadListBegin();
                                for (int _i88 = 0; _i88 < _list87.Count; ++_i88)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem89;
                                    _elem89 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem89.Read(iprot);
                                    DependabilityRequirements.Add(_elem89);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                SubFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list90 = iprot.ReadListBegin();
                                for (int _i91 = 0; _i91 < _list90.Count; ++_i91)
                                {
                                    TDDIAbstractFunctionRef _elem92;
                                    _elem92 = new TDDIAbstractFunctionRef();
                                    _elem92.Read(iprot);
                                    SubFunctions.Add(_elem92);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPort>();
                                TList _list93 = iprot.ReadListBegin();
                                for (int _i94 = 0; _i94 < _list93.Count; ++_i94)
                                {
                                    TDDIPort _elem95;
                                    _elem95 = new TDDIPort();
                                    _elem95.Read(iprot);
                                    Ports.Add(_elem95);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Signals = new List <TDDISignal>();
                                TList _list96 = iprot.ReadListBegin();
                                for (int _i97 = 0; _i97 < _list96.Count; ++_i97)
                                {
                                    TDDISignal _elem98;
                                    _elem98 = new TDDISignal();
                                    _elem98.Read(iprot);
                                    Signals.Add(_elem98);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Struct)
                        {
                            PerfChars = new TDDIPerfChars();
                            PerfChars.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list99 = iprot.ReadListBegin();
                                for (int _i100 = 0; _i100 < _list99.Count; ++_i100)
                                {
                                    TDDIAbstractFailureModelRef _elem101;
                                    _elem101 = new TDDIAbstractFailureModelRef();
                                    _elem101.Read(iprot);
                                    FailureModels.Add(_elem101);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                Malfunctions = new List <TDDIMalfunctionRef>();
                                TList _list102 = iprot.ReadListBegin();
                                for (int _i103 = 0; _i103 < _list102.Count; ++_i103)
                                {
                                    TDDIMalfunctionRef _elem104;
                                    _elem104 = new TDDIMalfunctionRef();
                                    _elem104.Read(iprot);
                                    Malfunctions.Add(_elem104);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.Struct)
                        {
                            AsAsset = new TDDIAbstractAsset();
                            AsAsset.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list1404 = iprot.ReadListBegin();
                                for (int _i1405 = 0; _i1405 < _list1404.Count; ++_i1405)
                                {
                                    TDDIKeyValueMap _elem1406;
                                    _elem1406 = new TDDIKeyValueMap();
                                    _elem1406.Read(iprot);
                                    KeyValueMaps.Add(_elem1406);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.String)
                        {
                            IntrinsicSafety = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.String)
                        {
                            SafeGuard = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.String)
                        {
                            ApplierInformation = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.Bool)
                        {
                            RiskAcceptability = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.String)
                        {
                            FurtherAction = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.String)
                        {
                            Source = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.Struct)
                        {
                            MeasureType = new TDDIMeasureType();
                            MeasureType.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.String)
                        {
                            Category = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.I32)
                        {
                            Type = (TDDISecurityApplicationType)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Vulnerabilities = new List <TDDIVulnerabilityRef>();
                                TList _list1407 = iprot.ReadListBegin();
                                for (int _i1408 = 0; _i1408 < _list1407.Count; ++_i1408)
                                {
                                    TDDIVulnerabilityRef _elem1409;
                                    _elem1409 = new TDDIVulnerabilityRef();
                                    _elem1409.Read(iprot);
                                    Vulnerabilities.Add(_elem1409);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 7
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list368 = iprot.ReadListBegin();
                                for (int _i369 = 0; _i369 < _list368.Count; ++_i369)
                                {
                                    TDDIKeyValueMapRef _elem370;
                                    _elem370 = new TDDIKeyValueMapRef();
                                    _elem370.Read(iprot);
                                    KeyValueMaps.Add(_elem370);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.String)
                        {
                            IntrinsicSafety = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.String)
                        {
                            SafeGuard = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.String)
                        {
                            ApplierInformation = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Bool)
                        {
                            RiskAcceptability = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.String)
                        {
                            FurtherAction = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.String)
                        {
                            Source = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.Struct)
                        {
                            MeasureType = new TDDIMeasureType();
                            MeasureType.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 8
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list104 = iprot.ReadListBegin();
                                for (int _i105 = 0; _i105 < _list104.Count; ++_i105)
                                {
                                    TDDIKeyValueMapRef _elem106;
                                    _elem106 = new TDDIKeyValueMapRef();
                                    _elem106.Read(iprot);
                                    KeyValueMaps.Add(_elem106);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list107 = iprot.ReadListBegin();
                                for (int _i108 = 0; _i108 < _list107.Count; ++_i108)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem109;
                                    _elem109 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem109.Read(iprot);
                                    DependabilityRequirements.Add(_elem109);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                SubSystems = new List <TDDIAbstractSystemRef>();
                                TList _list110 = iprot.ReadListBegin();
                                for (int _i111 = 0; _i111 < _list110.Count; ++_i111)
                                {
                                    TDDIAbstractSystemRef _elem112;
                                    _elem112 = new TDDIAbstractSystemRef();
                                    _elem112.Read(iprot);
                                    SubSystems.Add(_elem112);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Double)
                        {
                            OverallLifetime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.I32)
                        {
                            OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                RealisedFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list113 = iprot.ReadListBegin();
                                for (int _i114 = 0; _i114 < _list113.Count; ++_i114)
                                {
                                    TDDIAbstractFunctionRef _elem115;
                                    _elem115 = new TDDIAbstractFunctionRef();
                                    _elem115.Read(iprot);
                                    RealisedFunctions.Add(_elem115);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Configurations = new List <TDDIConfiguration>();
                                TList _list116 = iprot.ReadListBegin();
                                for (int _i117 = 0; _i117 < _list116.Count; ++_i117)
                                {
                                    TDDIConfiguration _elem118;
                                    _elem118 = new TDDIConfiguration();
                                    _elem118.Read(iprot);
                                    Configurations.Add(_elem118);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Contexts = new List <TDDIContext>();
                                TList _list119 = iprot.ReadListBegin();
                                for (int _i120 = 0; _i120 < _list119.Count; ++_i120)
                                {
                                    TDDIContext _elem121;
                                    _elem121 = new TDDIContext();
                                    _elem121.Read(iprot);
                                    Contexts.Add(_elem121);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.List)
                        {
                            {
                                SystemBoundaries = new List <TDDISystemBoundary>();
                                TList _list122 = iprot.ReadListBegin();
                                for (int _i123 = 0; _i123 < _list122.Count; ++_i123)
                                {
                                    TDDISystemBoundary _elem124;
                                    _elem124 = new TDDISystemBoundary();
                                    _elem124.Read(iprot);
                                    SystemBoundaries.Add(_elem124);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 17:
                        if (field.Type == TType.List)
                        {
                            {
                                AppliedStandards = new List <TDDIAbstractStandardRef>();
                                TList _list125 = iprot.ReadListBegin();
                                for (int _i126 = 0; _i126 < _list125.Count; ++_i126)
                                {
                                    TDDIAbstractStandardRef _elem127;
                                    _elem127 = new TDDIAbstractStandardRef();
                                    _elem127.Read(iprot);
                                    AppliedStandards.Add(_elem127);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 18:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list128 = iprot.ReadListBegin();
                                for (int _i129 = 0; _i129 < _list128.Count; ++_i129)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem130;
                                    _elem130 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem130.Read(iprot);
                                    FailureModels.Add(_elem130);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 19:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPortRef>();
                                TList _list131 = iprot.ReadListBegin();
                                for (int _i132 = 0; _i132 < _list131.Count; ++_i132)
                                {
                                    TDDIPortRef _elem133;
                                    _elem133 = new TDDIPortRef();
                                    _elem133.Read(iprot);
                                    Ports.Add(_elem133);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 9
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list284 = iprot.ReadListBegin();
                                for (int _i285 = 0; _i285 < _list284.Count; ++_i285)
                                {
                                    TDDIKeyValueMapRef _elem286;
                                    _elem286 = new TDDIKeyValueMapRef();
                                    _elem286.Read(iprot);
                                    KeyValueMaps.Add(_elem286);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list287 = iprot.ReadListBegin();
                                for (int _i288 = 0; _i288 < _list287.Count; ++_i288)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem289;
                                    _elem289 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem289.Read(iprot);
                                    DependabilityRequirements.Add(_elem289);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                SubFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list290 = iprot.ReadListBegin();
                                for (int _i291 = 0; _i291 < _list290.Count; ++_i291)
                                {
                                    TDDIAbstractFunctionRef _elem292;
                                    _elem292 = new TDDIAbstractFunctionRef();
                                    _elem292.Read(iprot);
                                    SubFunctions.Add(_elem292);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPortRef>();
                                TList _list293 = iprot.ReadListBegin();
                                for (int _i294 = 0; _i294 < _list293.Count; ++_i294)
                                {
                                    TDDIPortRef _elem295;
                                    _elem295 = new TDDIPortRef();
                                    _elem295.Read(iprot);
                                    Ports.Add(_elem295);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.Struct)
                        {
                            PerfChars = new TDDIPerfChars();
                            PerfChars.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list296 = iprot.ReadListBegin();
                                for (int _i297 = 0; _i297 < _list296.Count; ++_i297)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem298;
                                    _elem298 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem298.Read(iprot);
                                    FailureModels.Add(_elem298);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Malfunctions = new List <TDDIMalFunctionRef>();
                                TList _list299 = iprot.ReadListBegin();
                                for (int _i300 = 0; _i300 < _list299.Count; ++_i300)
                                {
                                    TDDIMalFunctionRef _elem301;
                                    _elem301 = new TDDIMalFunctionRef();
                                    _elem301.Read(iprot);
                                    Malfunctions.Add(_elem301);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 10
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list356 = iprot.ReadListBegin();
                                for (int _i357 = 0; _i357 < _list356.Count; ++_i357)
                                {
                                    TDDIKeyValueMap _elem358;
                                    _elem358 = new TDDIKeyValueMap();
                                    _elem358.Read(iprot);
                                    KeyValueMaps.Add(_elem358);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                Standards = new List <TDDIAbstractStandard>();
                                TList _list359 = iprot.ReadListBegin();
                                for (int _i360 = 0; _i360 < _list359.Count; ++_i360)
                                {
                                    TDDIAbstractStandard _elem361;
                                    _elem361 = new TDDIAbstractStandard();
                                    _elem361.Read(iprot);
                                    Standards.Add(_elem361);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                AssuranceLevels = new List <TDDIAssuranceLevel>();
                                TList _list362 = iprot.ReadListBegin();
                                for (int _i363 = 0; _i363 < _list362.Count; ++_i363)
                                {
                                    TDDIAssuranceLevel _elem364;
                                    _elem364 = new TDDIAssuranceLevel();
                                    _elem364.Read(iprot);
                                    AssuranceLevels.Add(_elem364);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 11
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list184 = iprot.ReadListBegin();
                                for (int _i185 = 0; _i185 < _list184.Count; ++_i185)
                                {
                                    TDDIKeyValueMapRef _elem186;
                                    _elem186 = new TDDIKeyValueMapRef();
                                    _elem186.Read(iprot);
                                    KeyValueMaps.Add(_elem186);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list187 = iprot.ReadListBegin();
                                for (int _i188 = 0; _i188 < _list187.Count; ++_i188)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem189;
                                    _elem189 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem189.Read(iprot);
                                    DependabilityRequirements.Add(_elem189);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                SubSystems = new List <TDDIAbstractSystemRef>();
                                TList _list190 = iprot.ReadListBegin();
                                for (int _i191 = 0; _i191 < _list190.Count; ++_i191)
                                {
                                    TDDIAbstractSystemRef _elem192;
                                    _elem192 = new TDDIAbstractSystemRef();
                                    _elem192.Read(iprot);
                                    SubSystems.Add(_elem192);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Double)
                        {
                            OverallLifetime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.I32)
                        {
                            OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                RealisedFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list193 = iprot.ReadListBegin();
                                for (int _i194 = 0; _i194 < _list193.Count; ++_i194)
                                {
                                    TDDIAbstractFunctionRef _elem195;
                                    _elem195 = new TDDIAbstractFunctionRef();
                                    _elem195.Read(iprot);
                                    RealisedFunctions.Add(_elem195);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Configurations = new List <TDDIConfiguration>();
                                TList _list196 = iprot.ReadListBegin();
                                for (int _i197 = 0; _i197 < _list196.Count; ++_i197)
                                {
                                    TDDIConfiguration _elem198;
                                    _elem198 = new TDDIConfiguration();
                                    _elem198.Read(iprot);
                                    Configurations.Add(_elem198);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Contexts = new List <TDDIContext>();
                                TList _list199 = iprot.ReadListBegin();
                                for (int _i200 = 0; _i200 < _list199.Count; ++_i200)
                                {
                                    TDDIContext _elem201;
                                    _elem201 = new TDDIContext();
                                    _elem201.Read(iprot);
                                    Contexts.Add(_elem201);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.List)
                        {
                            {
                                SystemBoundaries = new List <TDDISystemBoundary>();
                                TList _list202 = iprot.ReadListBegin();
                                for (int _i203 = 0; _i203 < _list202.Count; ++_i203)
                                {
                                    TDDISystemBoundary _elem204;
                                    _elem204 = new TDDISystemBoundary();
                                    _elem204.Read(iprot);
                                    SystemBoundaries.Add(_elem204);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 17:
                        if (field.Type == TType.List)
                        {
                            {
                                AppliedStandards = new List <TDDIAbstractStandardRef>();
                                TList _list205 = iprot.ReadListBegin();
                                for (int _i206 = 0; _i206 < _list205.Count; ++_i206)
                                {
                                    TDDIAbstractStandardRef _elem207;
                                    _elem207 = new TDDIAbstractStandardRef();
                                    _elem207.Read(iprot);
                                    AppliedStandards.Add(_elem207);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 18:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list208 = iprot.ReadListBegin();
                                for (int _i209 = 0; _i209 < _list208.Count; ++_i209)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem210;
                                    _elem210 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem210.Read(iprot);
                                    FailureModels.Add(_elem210);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 19:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPortRef>();
                                TList _list211 = iprot.ReadListBegin();
                                for (int _i212 = 0; _i212 < _list211.Count; ++_i212)
                                {
                                    TDDIPortRef _elem213;
                                    _elem213 = new TDDIPortRef();
                                    _elem213.Read(iprot);
                                    Ports.Add(_elem213);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 20:
                        if (field.Type == TType.String)
                        {
                            SafeState = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list112 = iprot.ReadListBegin();
                                for (int _i113 = 0; _i113 < _list112.Count; ++_i113)
                                {
                                    TDDIKeyValueMap _elem114;
                                    _elem114 = new TDDIKeyValueMap();
                                    _elem114.Read(iprot);
                                    KeyValueMaps.Add(_elem114);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list115 = iprot.ReadListBegin();
                                for (int _i116 = 0; _i116 < _list115.Count; ++_i116)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem117;
                                    _elem117 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem117.Read(iprot);
                                    DependabilityRequirements.Add(_elem117);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                SubFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list118 = iprot.ReadListBegin();
                                for (int _i119 = 0; _i119 < _list118.Count; ++_i119)
                                {
                                    TDDIAbstractFunctionRef _elem120;
                                    _elem120 = new TDDIAbstractFunctionRef();
                                    _elem120.Read(iprot);
                                    SubFunctions.Add(_elem120);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPort>();
                                TList _list121 = iprot.ReadListBegin();
                                for (int _i122 = 0; _i122 < _list121.Count; ++_i122)
                                {
                                    TDDIPort _elem123;
                                    _elem123 = new TDDIPort();
                                    _elem123.Read(iprot);
                                    Ports.Add(_elem123);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Signals = new List <TDDISignal>();
                                TList _list124 = iprot.ReadListBegin();
                                for (int _i125 = 0; _i125 < _list124.Count; ++_i125)
                                {
                                    TDDISignal _elem126;
                                    _elem126 = new TDDISignal();
                                    _elem126.Read(iprot);
                                    Signals.Add(_elem126);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Struct)
                        {
                            PerfChars = new TDDIPerfChars();
                            PerfChars.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list127 = iprot.ReadListBegin();
                                for (int _i128 = 0; _i128 < _list127.Count; ++_i128)
                                {
                                    TDDIAbstractFailureModelRef _elem129;
                                    _elem129 = new TDDIAbstractFailureModelRef();
                                    _elem129.Read(iprot);
                                    FailureModels.Add(_elem129);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                Malfunctions = new List <TDDIMalfunctionRef>();
                                TList _list130 = iprot.ReadListBegin();
                                for (int _i131 = 0; _i131 < _list130.Count; ++_i131)
                                {
                                    TDDIMalfunctionRef _elem132;
                                    _elem132 = new TDDIMalfunctionRef();
                                    _elem132.Read(iprot);
                                    Malfunctions.Add(_elem132);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.Struct)
                        {
                            AsAsset = new TDDIAbstractAsset();
                            AsAsset.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.String)
                        {
                            Object = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.String)
                        {
                            Behavior = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.String)
                        {
                            SafeState = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list12 = iprot.ReadListBegin();
                                for (int _i13 = 0; _i13 < _list12.Count; ++_i13)
                                {
                                    TDDIKeyValueMapRef _elem14;
                                    _elem14 = new TDDIKeyValueMapRef();
                                    _elem14.Read(iprot);
                                    KeyValueMaps.Add(_elem14);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list15 = iprot.ReadListBegin();
                                for (int _i16 = 0; _i16 < _list15.Count; ++_i16)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem17;
                                    _elem17 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem17.Read(iprot);
                                    DependabilityRequirements.Add(_elem17);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                DesignArtifacts = new List <TDDIAbstractDesignArtifactRef>();
                                TList _list18 = iprot.ReadListBegin();
                                for (int _i19 = 0; _i19 < _list18.Count; ++_i19)
                                {
                                    TDDIAbstractDesignArtifactRef _elem20;
                                    _elem20 = new TDDIAbstractDesignArtifactRef();
                                    _elem20.Read(iprot);
                                    DesignArtifacts.Add(_elem20);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Struct)
                        {
                            Implements = new TDDIAbstractArchitecturePackage();
                            Implements.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 14
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list144 = iprot.ReadListBegin();
                                for (int _i145 = 0; _i145 < _list144.Count; ++_i145)
                                {
                                    TDDIKeyValueMapRef _elem146;
                                    _elem146 = new TDDIKeyValueMapRef();
                                    _elem146.Read(iprot);
                                    KeyValueMaps.Add(_elem146);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list147 = iprot.ReadListBegin();
                                for (int _i148 = 0; _i148 < _list147.Count; ++_i148)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem149;
                                    _elem149 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem149.Read(iprot);
                                    DependabilityRequirements.Add(_elem149);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                SubSystems = new List <TDDIAbstractSystemRef>();
                                TList _list150 = iprot.ReadListBegin();
                                for (int _i151 = 0; _i151 < _list150.Count; ++_i151)
                                {
                                    TDDIAbstractSystemRef _elem152;
                                    _elem152 = new TDDIAbstractSystemRef();
                                    _elem152.Read(iprot);
                                    SubSystems.Add(_elem152);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Double)
                        {
                            OverallLifetime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.I32)
                        {
                            OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                RealisedFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list153 = iprot.ReadListBegin();
                                for (int _i154 = 0; _i154 < _list153.Count; ++_i154)
                                {
                                    TDDIAbstractFunctionRef _elem155;
                                    _elem155 = new TDDIAbstractFunctionRef();
                                    _elem155.Read(iprot);
                                    RealisedFunctions.Add(_elem155);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Configurations = new List <TDDIConfiguration>();
                                TList _list156 = iprot.ReadListBegin();
                                for (int _i157 = 0; _i157 < _list156.Count; ++_i157)
                                {
                                    TDDIConfiguration _elem158;
                                    _elem158 = new TDDIConfiguration();
                                    _elem158.Read(iprot);
                                    Configurations.Add(_elem158);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Contexts = new List <TDDIContext>();
                                TList _list159 = iprot.ReadListBegin();
                                for (int _i160 = 0; _i160 < _list159.Count; ++_i160)
                                {
                                    TDDIContext _elem161;
                                    _elem161 = new TDDIContext();
                                    _elem161.Read(iprot);
                                    Contexts.Add(_elem161);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.List)
                        {
                            {
                                SystemBoundaries = new List <TDDISystemBoundary>();
                                TList _list162 = iprot.ReadListBegin();
                                for (int _i163 = 0; _i163 < _list162.Count; ++_i163)
                                {
                                    TDDISystemBoundary _elem164;
                                    _elem164 = new TDDISystemBoundary();
                                    _elem164.Read(iprot);
                                    SystemBoundaries.Add(_elem164);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 17:
                        if (field.Type == TType.List)
                        {
                            {
                                AppliedStandards = new List <TDDIAbstractStandardRef>();
                                TList _list165 = iprot.ReadListBegin();
                                for (int _i166 = 0; _i166 < _list165.Count; ++_i166)
                                {
                                    TDDIAbstractStandardRef _elem167;
                                    _elem167 = new TDDIAbstractStandardRef();
                                    _elem167.Read(iprot);
                                    AppliedStandards.Add(_elem167);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 18:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list168 = iprot.ReadListBegin();
                                for (int _i169 = 0; _i169 < _list168.Count; ++_i169)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem170;
                                    _elem170 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem170.Read(iprot);
                                    FailureModels.Add(_elem170);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 19:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPortRef>();
                                TList _list171 = iprot.ReadListBegin();
                                for (int _i172 = 0; _i172 < _list171.Count; ++_i172)
                                {
                                    TDDIPortRef _elem173;
                                    _elem173 = new TDDIPortRef();
                                    _elem173.Read(iprot);
                                    Ports.Add(_elem173);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list912 = iprot.ReadListBegin();
                                for (int _i913 = 0; _i913 < _list912.Count; ++_i913)
                                {
                                    TDDIKeyValueMapRef _elem914;
                                    _elem914 = new TDDIKeyValueMapRef();
                                    _elem914.Read(iprot);
                                    KeyValueMaps.Add(_elem914);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.String)
                        {
                            DecompositionArgument = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                RefinedRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list915 = iprot.ReadListBegin();
                                for (int _i916 = 0; _i916 < _list915.Count; ++_i916)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem917;
                                    _elem917 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem917.Read(iprot);
                                    RefinedRequirements.Add(_elem917);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Struct)
                        {
                            RequirementSource = new TDDIAbstractRequirementSource();
                            RequirementSource.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Measures = new List <TDDIAbstractMeasureRef>();
                                TList _list918 = iprot.ReadListBegin();
                                for (int _i919 = 0; _i919 < _list918.Count; ++_i919)
                                {
                                    TDDIAbstractMeasureRef _elem920;
                                    _elem920 = new TDDIAbstractMeasureRef();
                                    _elem920.Read(iprot);
                                    Measures.Add(_elem920);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModes = new List <TDDIAbstractFailureRef>();
                                TList _list921 = iprot.ReadListBegin();
                                for (int _i922 = 0; _i922 < _list921.Count; ++_i922)
                                {
                                    TDDIAbstractFailureRef _elem923;
                                    _elem923 = new TDDIAbstractFailureRef();
                                    _elem923.Read(iprot);
                                    FailureModes.Add(_elem923);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                MaintenanceProcedures = new List <TDDIMaintenanceProcedureRef>();
                                TList _list924 = iprot.ReadListBegin();
                                for (int _i925 = 0; _i925 < _list924.Count; ++_i925)
                                {
                                    TDDIMaintenanceProcedureRef _elem926;
                                    _elem926 = new TDDIMaintenanceProcedureRef();
                                    _elem926.Read(iprot);
                                    MaintenanceProcedures.Add(_elem926);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                Hazards = new List <TDDIHazardRef>();
                                TList _list927 = iprot.ReadListBegin();
                                for (int _i928 = 0; _i928 < _list927.Count; ++_i928)
                                {
                                    TDDIHazardRef _elem929;
                                    _elem929 = new TDDIHazardRef();
                                    _elem929.Read(iprot);
                                    Hazards.Add(_elem929);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Double)
                        {
                            FailureReactionTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 17:
                        if (field.Type == TType.Double)
                        {
                            FailureDetectionTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 18:
                        if (field.Type == TType.Double)
                        {
                            FailureLatencyTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 19:
                        if (field.Type == TType.Bool)
                        {
                            IsSafetyGoal = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list656 = iprot.ReadListBegin();
                                for (int _i657 = 0; _i657 < _list656.Count; ++_i657)
                                {
                                    TDDIKeyValueMap _elem658;
                                    _elem658 = new TDDIKeyValueMap();
                                    _elem658.Read(iprot);
                                    KeyValueMaps.Add(_elem658);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.String)
                        {
                            DecompositionArgument = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                RefinedRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list659 = iprot.ReadListBegin();
                                for (int _i660 = 0; _i660 < _list659.Count; ++_i660)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem661;
                                    _elem661 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem661.Read(iprot);
                                    RefinedRequirements.Add(_elem661);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            RequirementSource = new TDDIAbstractRequirementSource();
                            RequirementSource.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Measures = new List <TDDIAbstractMeasureRef>();
                                TList _list662 = iprot.ReadListBegin();
                                for (int _i663 = 0; _i663 < _list662.Count; ++_i663)
                                {
                                    TDDIAbstractMeasureRef _elem664;
                                    _elem664 = new TDDIAbstractMeasureRef();
                                    _elem664.Read(iprot);
                                    Measures.Add(_elem664);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Failures = new List <TDDIAbstractFailureRef>();
                                TList _list665 = iprot.ReadListBegin();
                                for (int _i666 = 0; _i666 < _list665.Count; ++_i666)
                                {
                                    TDDIAbstractFailureRef _elem667;
                                    _elem667 = new TDDIAbstractFailureRef();
                                    _elem667.Read(iprot);
                                    Failures.Add(_elem667);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                MaintenanceProcedures = new List <TDDIMaintenanceProcedureRef>();
                                TList _list668 = iprot.ReadListBegin();
                                for (int _i669 = 0; _i669 < _list668.Count; ++_i669)
                                {
                                    TDDIMaintenanceProcedureRef _elem670;
                                    _elem670 = new TDDIMaintenanceProcedureRef();
                                    _elem670.Read(iprot);
                                    MaintenanceProcedures.Add(_elem670);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                Hazards = new List <TDDIHazardRef>();
                                TList _list671 = iprot.ReadListBegin();
                                for (int _i672 = 0; _i672 < _list671.Count; ++_i672)
                                {
                                    TDDIHazardRef _elem673;
                                    _elem673 = new TDDIHazardRef();
                                    _elem673.Read(iprot);
                                    Hazards.Add(_elem673);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.Double)
                        {
                            FailureReactionTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.Double)
                        {
                            FailureDetectionTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.Double)
                        {
                            FailureLatencyTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Bool)
                        {
                            IsSafetyGoal = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 17
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list72 = iprot.ReadListBegin();
                                for (int _i73 = 0; _i73 < _list72.Count; ++_i73)
                                {
                                    TDDIKeyValueMapRef _elem74;
                                    _elem74 = new TDDIKeyValueMapRef();
                                    _elem74.Read(iprot);
                                    KeyValueMaps.Add(_elem74);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list75 = iprot.ReadListBegin();
                                for (int _i76 = 0; _i76 < _list75.Count; ++_i76)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem77;
                                    _elem77 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem77.Read(iprot);
                                    DependabilityRequirements.Add(_elem77);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                SubSystems = new List <TDDIAbstractSystemRef>();
                                TList _list78 = iprot.ReadListBegin();
                                for (int _i79 = 0; _i79 < _list78.Count; ++_i79)
                                {
                                    TDDIAbstractSystemRef _elem80;
                                    _elem80 = new TDDIAbstractSystemRef();
                                    _elem80.Read(iprot);
                                    SubSystems.Add(_elem80);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list84 = iprot.ReadListBegin();
                                for (int _i85 = 0; _i85 < _list84.Count; ++_i85)
                                {
                                    TDDIKeyValueMapRef _elem86;
                                    _elem86 = new TDDIKeyValueMapRef();
                                    _elem86.Read(iprot);
                                    KeyValueMaps.Add(_elem86);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list87 = iprot.ReadListBegin();
                                for (int _i88 = 0; _i88 < _list87.Count; ++_i88)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem89;
                                    _elem89 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem89.Read(iprot);
                                    DependabilityRequirements.Add(_elem89);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.String)
                        {
                            UsageHistory = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.Double)
                        {
                            MissionTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.I32)
                        {
                            MissionTimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 19
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list48 = iprot.ReadListBegin();
                                for (int _i49 = 0; _i49 < _list48.Count; ++_i49)
                                {
                                    TDDIKeyValueMapRef _elem50;
                                    _elem50 = new TDDIKeyValueMapRef();
                                    _elem50.Read(iprot);
                                    KeyValueMaps.Add(_elem50);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list51 = iprot.ReadListBegin();
                                for (int _i52 = 0; _i52 < _list51.Count; ++_i52)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem53;
                                    _elem53 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem53.Read(iprot);
                                    DependabilityRequirements.Add(_elem53);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.String)
                        {
                            FlowType = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.I32)
                        {
                            Direction = (TDDIPortDirection)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                RefinedPorts = new List <TDDIPortRef>();
                                TList _list54 = iprot.ReadListBegin();
                                for (int _i55 = 0; _i55 < _list54.Count; ++_i55)
                                {
                                    TDDIPortRef _elem56;
                                    _elem56 = new TDDIPortRef();
                                    _elem56.Read(iprot);
                                    RefinedPorts.Add(_elem56);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                InterfaceFailures = new List <TDDIAbstractInterfaceFailureRef>();
                                TList _list57 = iprot.ReadListBegin();
                                for (int _i58 = 0; _i58 < _list57.Count; ++_i58)
                                {
                                    TDDIAbstractInterfaceFailureRef _elem59;
                                    _elem59 = new TDDIAbstractInterfaceFailureRef();
                                    _elem59.Read(iprot);
                                    InterfaceFailures.Add(_elem59);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 20
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list196 = iprot.ReadListBegin();
                                for (int _i197 = 0; _i197 < _list196.Count; ++_i197)
                                {
                                    TDDIKeyValueMap _elem198;
                                    _elem198 = new TDDIKeyValueMap();
                                    _elem198.Read(iprot);
                                    KeyValueMaps.Add(_elem198);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Double)
                        {
                            OverallLifetime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.I32)
                        {
                            OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                Contexts = new List <TDDIContext>();
                                TList _list199 = iprot.ReadListBegin();
                                for (int _i200 = 0; _i200 < _list199.Count; ++_i200)
                                {
                                    TDDIContext _elem201;
                                    _elem201 = new TDDIContext();
                                    _elem201.Read(iprot);
                                    Contexts.Add(_elem201);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Configurations = new List <TDDIConfiguration>();
                                TList _list202 = iprot.ReadListBegin();
                                for (int _i203 = 0; _i203 < _list202.Count; ++_i203)
                                {
                                    TDDIConfiguration _elem204;
                                    _elem204 = new TDDIConfiguration();
                                    _elem204.Read(iprot);
                                    Configurations.Add(_elem204);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPort>();
                                TList _list205 = iprot.ReadListBegin();
                                for (int _i206 = 0; _i206 < _list205.Count; ++_i206)
                                {
                                    TDDIPort _elem207;
                                    _elem207 = new TDDIPort();
                                    _elem207.Read(iprot);
                                    Ports.Add(_elem207);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                Signals = new List <TDDISignal>();
                                TList _list208 = iprot.ReadListBegin();
                                for (int _i209 = 0; _i209 < _list208.Count; ++_i209)
                                {
                                    TDDISignal _elem210;
                                    _elem210 = new TDDISignal();
                                    _elem210.Read(iprot);
                                    Signals.Add(_elem210);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                SystemBoundaries = new List <TDDISystemBoundary>();
                                TList _list211 = iprot.ReadListBegin();
                                for (int _i212 = 0; _i212 < _list211.Count; ++_i212)
                                {
                                    TDDISystemBoundary _elem213;
                                    _elem213 = new TDDISystemBoundary();
                                    _elem213.Read(iprot);
                                    SystemBoundaries.Add(_elem213);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                AppliedStandards = new List <TDDIAbstractStandardRef>();
                                TList _list214 = iprot.ReadListBegin();
                                for (int _i215 = 0; _i215 < _list214.Count; ++_i215)
                                {
                                    TDDIAbstractStandardRef _elem216;
                                    _elem216 = new TDDIAbstractStandardRef();
                                    _elem216.Read(iprot);
                                    AppliedStandards.Add(_elem216);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                RealisedFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list217 = iprot.ReadListBegin();
                                for (int _i218 = 0; _i218 < _list217.Count; ++_i218)
                                {
                                    TDDIAbstractFunctionRef _elem219;
                                    _elem219 = new TDDIAbstractFunctionRef();
                                    _elem219.Read(iprot);
                                    RealisedFunctions.Add(_elem219);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.Struct)
                        {
                            AsAsset = new TDDIAbstractAsset();
                            AsAsset.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list220 = iprot.ReadListBegin();
                                for (int _i221 = 0; _i221 < _list220.Count; ++_i221)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem222;
                                    _elem222 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem222.Read(iprot);
                                    DependabilityRequirements.Add(_elem222);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 17:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list223 = iprot.ReadListBegin();
                                for (int _i224 = 0; _i224 < _list223.Count; ++_i224)
                                {
                                    TDDIAbstractFailureModelRef _elem225;
                                    _elem225 = new TDDIAbstractFailureModelRef();
                                    _elem225.Read(iprot);
                                    FailureModels.Add(_elem225);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 18:
                        if (field.Type == TType.List)
                        {
                            {
                                SubSystems = new List <TDDIAbstractSystemRef>();
                                TList _list226 = iprot.ReadListBegin();
                                for (int _i227 = 0; _i227 < _list226.Count; ++_i227)
                                {
                                    TDDIAbstractSystemRef _elem228;
                                    _elem228 = new TDDIAbstractSystemRef();
                                    _elem228.Read(iprot);
                                    SubSystems.Add(_elem228);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 21
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list40 = iprot.ReadListBegin();
                                for (int _i41 = 0; _i41 < _list40.Count; ++_i41)
                                {
                                    TDDIKeyValueMapRef _elem42;
                                    _elem42 = new TDDIKeyValueMapRef();
                                    _elem42.Read(iprot);
                                    KeyValueMaps.Add(_elem42);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list43 = iprot.ReadListBegin();
                                for (int _i44 = 0; _i44 < _list43.Count; ++_i44)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem45;
                                    _elem45 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem45.Read(iprot);
                                    DependabilityRequirements.Add(_elem45);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Double)
                        {
                            ResponseTime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.Struct)
                        {
                            DomainPackage = new TDDIAbstractDomainPackage();
                            DomainPackage.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.Struct)
                        {
                            Standard = new TDDIAbstractStandard();
                            Standard.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list224 = iprot.ReadListBegin();
                                for (int _i225 = 0; _i225 < _list224.Count; ++_i225)
                                {
                                    TDDIKeyValueMapRef _elem226;
                                    _elem226 = new TDDIKeyValueMapRef();
                                    _elem226.Read(iprot);
                                    KeyValueMaps.Add(_elem226);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list227 = iprot.ReadListBegin();
                                for (int _i228 = 0; _i228 < _list227.Count; ++_i228)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem229;
                                    _elem229 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem229.Read(iprot);
                                    DependabilityRequirements.Add(_elem229);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.String)
                        {
                            Value = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Conditions = new List <TDDILifecycleConditionRef>();
                                TList _list230 = iprot.ReadListBegin();
                                for (int _i231 = 0; _i231 < _list230.Count; ++_i231)
                                {
                                    TDDILifecycleConditionRef _elem232;
                                    _elem232 = new TDDILifecycleConditionRef();
                                    _elem232.Read(iprot);
                                    Conditions.Add(_elem232);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list240 = iprot.ReadListBegin();
                                for (int _i241 = 0; _i241 < _list240.Count; ++_i241)
                                {
                                    TDDIKeyValueMap _elem242;
                                    _elem242 = new TDDIKeyValueMap();
                                    _elem242.Read(iprot);
                                    KeyValueMaps.Add(_elem242);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Double)
                        {
                            OverallLifetime = iprot.ReadDouble();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.I32)
                        {
                            OverallLifetimeTimeUnit = (TDDITimeUnit)iprot.ReadI32();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                Contexts = new List <TDDIContext>();
                                TList _list243 = iprot.ReadListBegin();
                                for (int _i244 = 0; _i244 < _list243.Count; ++_i244)
                                {
                                    TDDIContext _elem245;
                                    _elem245 = new TDDIContext();
                                    _elem245.Read(iprot);
                                    Contexts.Add(_elem245);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Configurations = new List <TDDIConfiguration>();
                                TList _list246 = iprot.ReadListBegin();
                                for (int _i247 = 0; _i247 < _list246.Count; ++_i247)
                                {
                                    TDDIConfiguration _elem248;
                                    _elem248 = new TDDIConfiguration();
                                    _elem248.Read(iprot);
                                    Configurations.Add(_elem248);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPort>();
                                TList _list249 = iprot.ReadListBegin();
                                for (int _i250 = 0; _i250 < _list249.Count; ++_i250)
                                {
                                    TDDIPort _elem251;
                                    _elem251 = new TDDIPort();
                                    _elem251.Read(iprot);
                                    Ports.Add(_elem251);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                Signals = new List <TDDISignal>();
                                TList _list252 = iprot.ReadListBegin();
                                for (int _i253 = 0; _i253 < _list252.Count; ++_i253)
                                {
                                    TDDISignal _elem254;
                                    _elem254 = new TDDISignal();
                                    _elem254.Read(iprot);
                                    Signals.Add(_elem254);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                SystemBoundaries = new List <TDDISystemBoundary>();
                                TList _list255 = iprot.ReadListBegin();
                                for (int _i256 = 0; _i256 < _list255.Count; ++_i256)
                                {
                                    TDDISystemBoundary _elem257;
                                    _elem257 = new TDDISystemBoundary();
                                    _elem257.Read(iprot);
                                    SystemBoundaries.Add(_elem257);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                AppliedStandards = new List <TDDIAbstractStandardRef>();
                                TList _list258 = iprot.ReadListBegin();
                                for (int _i259 = 0; _i259 < _list258.Count; ++_i259)
                                {
                                    TDDIAbstractStandardRef _elem260;
                                    _elem260 = new TDDIAbstractStandardRef();
                                    _elem260.Read(iprot);
                                    AppliedStandards.Add(_elem260);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                RealisedFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list261 = iprot.ReadListBegin();
                                for (int _i262 = 0; _i262 < _list261.Count; ++_i262)
                                {
                                    TDDIAbstractFunctionRef _elem263;
                                    _elem263 = new TDDIAbstractFunctionRef();
                                    _elem263.Read(iprot);
                                    RealisedFunctions.Add(_elem263);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.Struct)
                        {
                            AsAsset = new TDDIAbstractAsset();
                            AsAsset.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list264 = iprot.ReadListBegin();
                                for (int _i265 = 0; _i265 < _list264.Count; ++_i265)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem266;
                                    _elem266 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem266.Read(iprot);
                                    DependabilityRequirements.Add(_elem266);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 17:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list267 = iprot.ReadListBegin();
                                for (int _i268 = 0; _i268 < _list267.Count; ++_i268)
                                {
                                    TDDIAbstractFailureModelRef _elem269;
                                    _elem269 = new TDDIAbstractFailureModelRef();
                                    _elem269.Read(iprot);
                                    FailureModels.Add(_elem269);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 18:
                        if (field.Type == TType.List)
                        {
                            {
                                SubSystems = new List <TDDIAbstractSystemRef>();
                                TList _list270 = iprot.ReadListBegin();
                                for (int _i271 = 0; _i271 < _list270.Count; ++_i271)
                                {
                                    TDDIAbstractSystemRef _elem272;
                                    _elem272 = new TDDIAbstractSystemRef();
                                    _elem272.Read(iprot);
                                    SubSystems.Add(_elem272);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 19:
                        if (field.Type == TType.String)
                        {
                            SafeState = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 25
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list680 = iprot.ReadListBegin();
                                for (int _i681 = 0; _i681 < _list680.Count; ++_i681)
                                {
                                    TDDIKeyValueMap _elem682;
                                    _elem682 = new TDDIKeyValueMap();
                                    _elem682.Read(iprot);
                                    KeyValueMaps.Add(_elem682);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.String)
                        {
                            DecompositionArgument = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                RefinedRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list683 = iprot.ReadListBegin();
                                for (int _i684 = 0; _i684 < _list683.Count; ++_i684)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem685;
                                    _elem685 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem685.Read(iprot);
                                    RefinedRequirements.Add(_elem685);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            RequirementSource = new TDDIAbstractRequirementSource();
                            RequirementSource.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Measures = new List <TDDIAbstractMeasureRef>();
                                TList _list686 = iprot.ReadListBegin();
                                for (int _i687 = 0; _i687 < _list686.Count; ++_i687)
                                {
                                    TDDIAbstractMeasureRef _elem688;
                                    _elem688 = new TDDIAbstractMeasureRef();
                                    _elem688.Read(iprot);
                                    Measures.Add(_elem688);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Failures = new List <TDDIAbstractFailureRef>();
                                TList _list689 = iprot.ReadListBegin();
                                for (int _i690 = 0; _i690 < _list689.Count; ++_i690)
                                {
                                    TDDIAbstractFailureRef _elem691;
                                    _elem691 = new TDDIAbstractFailureRef();
                                    _elem691.Read(iprot);
                                    Failures.Add(_elem691);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                MaintenanceProcedures = new List <TDDIMaintenanceProcedureRef>();
                                TList _list692 = iprot.ReadListBegin();
                                for (int _i693 = 0; _i693 < _list692.Count; ++_i693)
                                {
                                    TDDIMaintenanceProcedureRef _elem694;
                                    _elem694 = new TDDIMaintenanceProcedureRef();
                                    _elem694.Read(iprot);
                                    MaintenanceProcedures.Add(_elem694);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.List)
                        {
                            {
                                SecurityCapabilities = new List <TDDISecurityCapabilityRef>();
                                TList _list695 = iprot.ReadListBegin();
                                for (int _i696 = 0; _i696 < _list695.Count; ++_i696)
                                {
                                    TDDISecurityCapabilityRef _elem697;
                                    _elem697 = new TDDISecurityCapabilityRef();
                                    _elem697.Read(iprot);
                                    SecurityCapabilities.Add(_elem697);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 26
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2:
                        if (field.Type == TType.String)
                        {
                            Name = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3:
                        if (field.Type == TType.String)
                        {
                            Description = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4:
                        if (field.Type == TType.Bool)
                        {
                            IsCitation = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Bool)
                        {
                            IsAbstract = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _list308 = iprot.ReadListBegin();
                                for (int _i309 = 0; _i309 < _list308.Count; ++_i309)
                                {
                                    TDDIKeyValueMapRef _elem310;
                                    _elem310 = new TDDIKeyValueMapRef();
                                    _elem310.Read(iprot);
                                    KeyValueMaps.Add(_elem310);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.Struct)
                        {
                            CitedElement = new TDDIAbstractBaseElement();
                            CitedElement.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                DependabilityRequirements = new List <TDDIAbstractDependabilityRequirementRef>();
                                TList _list311 = iprot.ReadListBegin();
                                for (int _i312 = 0; _i312 < _list311.Count; ++_i312)
                                {
                                    TDDIAbstractDependabilityRequirementRef _elem313;
                                    _elem313 = new TDDIAbstractDependabilityRequirementRef();
                                    _elem313.Read(iprot);
                                    DependabilityRequirements.Add(_elem313);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.Struct)
                        {
                            AssuranceLevel = new TDDIAssuranceLevel();
                            AssuranceLevel.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.List)
                        {
                            {
                                SubFunctions = new List <TDDIAbstractFunctionRef>();
                                TList _list314 = iprot.ReadListBegin();
                                for (int _i315 = 0; _i315 < _list314.Count; ++_i315)
                                {
                                    TDDIAbstractFunctionRef _elem316;
                                    _elem316 = new TDDIAbstractFunctionRef();
                                    _elem316.Read(iprot);
                                    SubFunctions.Add(_elem316);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 11:
                        if (field.Type == TType.List)
                        {
                            {
                                Ports = new List <TDDIPortRef>();
                                TList _list317 = iprot.ReadListBegin();
                                for (int _i318 = 0; _i318 < _list317.Count; ++_i318)
                                {
                                    TDDIPortRef _elem319;
                                    _elem319 = new TDDIPortRef();
                                    _elem319.Read(iprot);
                                    Ports.Add(_elem319);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 12:
                        if (field.Type == TType.Struct)
                        {
                            PerfChars = new TDDIPerfChars();
                            PerfChars.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 13:
                        if (field.Type == TType.List)
                        {
                            {
                                FailureModels = new List <TDDIAbstractFailureLogicPackageRef>();
                                TList _list320 = iprot.ReadListBegin();
                                for (int _i321 = 0; _i321 < _list320.Count; ++_i321)
                                {
                                    TDDIAbstractFailureLogicPackageRef _elem322;
                                    _elem322 = new TDDIAbstractFailureLogicPackageRef();
                                    _elem322.Read(iprot);
                                    FailureModels.Add(_elem322);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 14:
                        if (field.Type == TType.List)
                        {
                            {
                                Malfunctions = new List <TDDIMalFunctionRef>();
                                TList _list323 = iprot.ReadListBegin();
                                for (int _i324 = 0; _i324 < _list323.Count; ++_i324)
                                {
                                    TDDIMalFunctionRef _elem325;
                                    _elem325 = new TDDIMalFunctionRef();
                                    _elem325.Read(iprot);
                                    Malfunctions.Add(_elem325);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 15:
                        if (field.Type == TType.String)
                        {
                            Object = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 16:
                        if (field.Type == TType.String)
                        {
                            Behavior = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 17:
                        if (field.Type == TType.String)
                        {
                            SafeState = iprot.ReadString();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }