示例#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.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();
            }
        }
        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();
            }
        }
示例#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.Struct)
                        {
                            System = new TDDIAbstractSystem();
                            System.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 4:
                        if (field.Type == TType.Struct)
                        {
                            Signal = new TDDISignal();
                            Signal.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 5:
                        if (field.Type == TType.Struct)
                        {
                            SystemBoundary = new TDDISystemBoundary();
                            SystemBoundary.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    case 8:
                        if (field.Type == TType.Struct)
                        {
                            Port = new TDDIPort();
                            Port.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
示例#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();
            }
        }
示例#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.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();
            }
        }
示例#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.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();
            }
        }