Ejemplo n.º 1
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 _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.º 3
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 _list464 = iprot.ReadListBegin();
                                for (int _i465 = 0; _i465 < _list464.Count; ++_i465)
                                {
                                    TDDIKeyValueMap _elem466;
                                    _elem466 = new TDDIKeyValueMap();
                                    _elem466.Read(iprot);
                                    KeyValueMaps.Add(_elem466);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                MinimalCutSets = new List <TDDIMinimalCutSets>();
                                TList _list467 = iprot.ReadListBegin();
                                for (int _i468 = 0; _i468 < _list467.Count; ++_i468)
                                {
                                    TDDIMinimalCutSets _elem469;
                                    _elem469 = new TDDIMinimalCutSets();
                                    _elem469.Read(iprot);
                                    MinimalCutSets.Add(_elem469);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                Failures = new List <TDDIAbstractFailure>();
                                TList _list470 = iprot.ReadListBegin();
                                for (int _i471 = 0; _i471 < _list470.Count; ++_i471)
                                {
                                    TDDIAbstractFailure _elem472;
                                    _elem472 = new TDDIAbstractFailure();
                                    _elem472.Read(iprot);
                                    Failures.Add(_elem472);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                SubModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list473 = iprot.ReadListBegin();
                                for (int _i474 = 0; _i474 < _list473.Count; ++_i474)
                                {
                                    TDDIAbstractFailureModelRef _elem475;
                                    _elem475 = new TDDIAbstractFailureModelRef();
                                    _elem475.Read(iprot);
                                    SubModels.Add(_elem475);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                Entries = new List <TDDIAbstractFMEAEntry>();
                                TList _list476 = iprot.ReadListBegin();
                                for (int _i477 = 0; _i477 < _list476.Count; ++_i477)
                                {
                                    TDDIAbstractFMEAEntry _elem478;
                                    _elem478 = new TDDIAbstractFMEAEntry();
                                    _elem478.Read(iprot);
                                    Entries.Add(_elem478);
                                }
                                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.º 4
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();
            }
        }
        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 _list432 = iprot.ReadListBegin();
                                for (int _i433 = 0; _i433 < _list432.Count; ++_i433)
                                {
                                    TDDIKeyValueMap _elem434;
                                    _elem434 = new TDDIKeyValueMap();
                                    _elem434.Read(iprot);
                                    KeyValueMaps.Add(_elem434);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                MinimalCutSets = new List <TDDIMinimalCutSets>();
                                TList _list435 = iprot.ReadListBegin();
                                for (int _i436 = 0; _i436 < _list435.Count; ++_i436)
                                {
                                    TDDIMinimalCutSets _elem437;
                                    _elem437 = new TDDIMinimalCutSets();
                                    _elem437.Read(iprot);
                                    MinimalCutSets.Add(_elem437);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                Failures = new List <TDDIAbstractFailure>();
                                TList _list438 = iprot.ReadListBegin();
                                for (int _i439 = 0; _i439 < _list438.Count; ++_i439)
                                {
                                    TDDIAbstractFailure _elem440;
                                    _elem440 = new TDDIAbstractFailure();
                                    _elem440.Read(iprot);
                                    Failures.Add(_elem440);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                SubModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list441 = iprot.ReadListBegin();
                                for (int _i442 = 0; _i442 < _list441.Count; ++_i442)
                                {
                                    TDDIAbstractFailureModelRef _elem443;
                                    _elem443 = new TDDIAbstractFailureModelRef();
                                    _elem443.Read(iprot);
                                    SubModels.Add(_elem443);
                                }
                                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.º 6
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 _list628 = iprot.ReadListBegin();
                                for (int _i629 = 0; _i629 < _list628.Count; ++_i629)
                                {
                                    TDDIKeyValueMap _elem630;
                                    _elem630 = new TDDIKeyValueMap();
                                    _elem630.Read(iprot);
                                    KeyValueMaps.Add(_elem630);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                MinimalCutSets = new List <TDDIMinimalCutSets>();
                                TList _list631 = iprot.ReadListBegin();
                                for (int _i632 = 0; _i632 < _list631.Count; ++_i632)
                                {
                                    TDDIMinimalCutSets _elem633;
                                    _elem633 = new TDDIMinimalCutSets();
                                    _elem633.Read(iprot);
                                    MinimalCutSets.Add(_elem633);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                Failures = new List <TDDIAbstractFailure>();
                                TList _list634 = iprot.ReadListBegin();
                                for (int _i635 = 0; _i635 < _list634.Count; ++_i635)
                                {
                                    TDDIAbstractFailure _elem636;
                                    _elem636 = new TDDIAbstractFailure();
                                    _elem636.Read(iprot);
                                    Failures.Add(_elem636);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                SubModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list637 = iprot.ReadListBegin();
                                for (int _i638 = 0; _i638 < _list637.Count; ++_i638)
                                {
                                    TDDIAbstractFailureModelRef _elem639;
                                    _elem639 = new TDDIAbstractFailureModelRef();
                                    _elem639.Read(iprot);
                                    SubModels.Add(_elem639);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Transitions = new List <TDDITransition>();
                                TList _list640 = iprot.ReadListBegin();
                                for (int _i641 = 0; _i641 < _list640.Count; ++_i641)
                                {
                                    TDDITransition _elem642;
                                    _elem642 = new TDDITransition();
                                    _elem642.Read(iprot);
                                    Transitions.Add(_elem642);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 9:
                        if (field.Type == TType.List)
                        {
                            {
                                States = new List <TDDIState>();
                                TList _list643 = iprot.ReadListBegin();
                                for (int _i644 = 0; _i644 < _list643.Count; ++_i644)
                                {
                                    TDDIState _elem645;
                                    _elem645 = new TDDIState();
                                    _elem645.Read(iprot);
                                    States.Add(_elem645);
                                }
                                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 _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.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMap>();
                                TList _list496 = iprot.ReadListBegin();
                                for (int _i497 = 0; _i497 < _list496.Count; ++_i497)
                                {
                                    TDDIKeyValueMap _elem498;
                                    _elem498 = new TDDIKeyValueMap();
                                    _elem498.Read(iprot);
                                    KeyValueMaps.Add(_elem498);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.List)
                        {
                            {
                                MinimalCutSets = new List <TDDIMinimalCutSets>();
                                TList _list499 = iprot.ReadListBegin();
                                for (int _i500 = 0; _i500 < _list499.Count; ++_i500)
                                {
                                    TDDIMinimalCutSets _elem501;
                                    _elem501 = new TDDIMinimalCutSets();
                                    _elem501.Read(iprot);
                                    MinimalCutSets.Add(_elem501);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                Failures = new List <TDDIAbstractFailure>();
                                TList _list502 = iprot.ReadListBegin();
                                for (int _i503 = 0; _i503 < _list502.Count; ++_i503)
                                {
                                    TDDIAbstractFailure _elem504;
                                    _elem504 = new TDDIAbstractFailure();
                                    _elem504.Read(iprot);
                                    Failures.Add(_elem504);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 7:
                        if (field.Type == TType.List)
                        {
                            {
                                SubModels = new List <TDDIAbstractFailureModelRef>();
                                TList _list505 = iprot.ReadListBegin();
                                for (int _i506 = 0; _i506 < _list505.Count; ++_i506)
                                {
                                    TDDIAbstractFailureModelRef _elem507;
                                    _elem507 = new TDDIAbstractFailureModelRef();
                                    _elem507.Read(iprot);
                                    SubModels.Add(_elem507);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 8:
                        if (field.Type == TType.List)
                        {
                            {
                                Causes = new List <TDDIAbstractCause>();
                                TList _list508 = iprot.ReadListBegin();
                                for (int _i509 = 0; _i509 < _list508.Count; ++_i509)
                                {
                                    TDDIAbstractCause _elem510;
                                    _elem510 = new TDDIAbstractCause();
                                    _elem510.Read(iprot);
                                    Causes.Add(_elem510);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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