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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Beispiel #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.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 _list52 = iprot.ReadListBegin();
                                for (int _i53 = 0; _i53 < _list52.Count; ++_i53)
                                {
                                    TDDIKeyValueMap _elem54;
                                    _elem54 = new TDDIKeyValueMap();
                                    _elem54.Read(iprot);
                                    KeyValueMaps.Add(_elem54);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Beispiel #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 _list284 = iprot.ReadListBegin();
                                for (int _i285 = 0; _i285 < _list284.Count; ++_i285)
                                {
                                    TDDIKeyValueMapRef _elem286;
                                    _elem286 = new TDDIKeyValueMapRef();
                                    _elem286.Read(iprot);
                                    KeyValueMaps.Add(_elem286);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

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

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

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Beispiel #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 _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();
            }
        }
Beispiel #7
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

                    case 6:
                        if (field.Type == TType.List)
                        {
                            {
                                KeyValueMaps = new List <TDDIKeyValueMapRef>();
                                TList _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();
            }
        }
Beispiel #8
0
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.I64)
                        {
                            Id = iprot.ReadI64();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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