Beispiel #1
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("TimUserBean");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (Tid != null && __isset.tid)
         {
             field.Name = "tid";
             field.Type = TType.Struct;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             Tid.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (Nickname != null && __isset.nickname)
         {
             field.Name = "nickname";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Nickname);
             oprot.WriteFieldEnd();
         }
         if (Remarkname != null && __isset.remarkname)
         {
             field.Name = "remarkname";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Remarkname);
             oprot.WriteFieldEnd();
         }
         if (Brithday != null && __isset.brithday)
         {
             field.Name = "brithday";
             field.Type = TType.String;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Brithday);
             oprot.WriteFieldEnd();
         }
         if (__isset.gender)
         {
             field.Name = "gender";
             field.Type = TType.I16;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(Gender);
             oprot.WriteFieldEnd();
         }
         if (Headurl != null && __isset.headurl)
         {
             field.Name = "headurl";
             field.Type = TType.String;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Headurl);
             oprot.WriteFieldEnd();
         }
         if (Area != null && __isset.area)
         {
             field.Name = "area";
             field.Type = TType.Struct;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             Area.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (Headbyte != null && __isset.headbyte)
         {
             field.Name = "headbyte";
             field.Type = TType.String;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             oprot.WriteBinary(Headbyte);
             oprot.WriteFieldEnd();
         }
         if (PhotoBytes != null && __isset.photoBytes)
         {
             field.Name = "photoBytes";
             field.Type = TType.List;
             field.ID   = 9;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.String, PhotoBytes.Count));
                 foreach (byte[] _iter46 in PhotoBytes)
                 {
                     oprot.WriteBinary(_iter46);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (ExtraList != null && __isset.extraList)
         {
             field.Name = "extraList";
             field.Type = TType.List;
             field.ID   = 10;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, ExtraList.Count));
                 foreach (TimNode _iter47 in ExtraList)
                 {
                     _iter47.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (ExtraMap != null && __isset.extraMap)
         {
             field.Name = "extraMap";
             field.Type = TType.Map;
             field.ID   = 11;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteMapBegin(new TMap(TType.String, TType.String, ExtraMap.Count));
                 foreach (string _iter48 in ExtraMap.Keys)
                 {
                     oprot.WriteString(_iter48);
                     oprot.WriteString(ExtraMap[_iter48]);
                 }
                 oprot.WriteMapEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("TDDICause");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.Id)
         {
             field.Name = "Id";
             field.Type = TType.I64;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Id);
             oprot.WriteFieldEnd();
         }
         if (Name != null && __isset.Name)
         {
             field.Name = "Name";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Name);
             oprot.WriteFieldEnd();
         }
         if (Description != null && __isset.Description)
         {
             field.Name = "Description";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Description);
             oprot.WriteFieldEnd();
         }
         if (KeyValueMaps != null && __isset.KeyValueMaps)
         {
             field.Name = "KeyValueMaps";
             field.Type = TType.List;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, KeyValueMaps.Count));
                 foreach (TDDIKeyValueMap _iter487 in KeyValueMaps)
                 {
                     _iter487.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (__isset.Type)
         {
             field.Name = "Type";
             field.Type = TType.I32;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Type);
             oprot.WriteFieldEnd();
         }
         if (Failure != null && __isset.Failure)
         {
             field.Name = "Failure";
             field.Type = TType.Struct;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             Failure.Write(oprot);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #3
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("MServiceDescription");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (Name == null)
         {
             throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Name not set");
         }
         field.Name = "Name";
         field.Type = TType.String;
         field.ID   = 1;
         oprot.WriteFieldBegin(field);
         oprot.WriteString(Name);
         oprot.WriteFieldEnd();
         if (ID == null)
         {
             throw new TProtocolException(TProtocolException.INVALID_DATA, "required field ID not set");
         }
         field.Name = "ID";
         field.Type = TType.String;
         field.ID   = 2;
         oprot.WriteFieldBegin(field);
         oprot.WriteString(ID);
         oprot.WriteFieldEnd();
         if (Language == null)
         {
             throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Language not set");
         }
         field.Name = "Language";
         field.Type = TType.String;
         field.ID   = 3;
         oprot.WriteFieldBegin(field);
         oprot.WriteString(Language);
         oprot.WriteFieldEnd();
         if (Addresses == null)
         {
             throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Addresses not set");
         }
         field.Name = "Addresses";
         field.Type = TType.List;
         field.ID   = 4;
         oprot.WriteFieldBegin(field);
         {
             oprot.WriteListBegin(new TList(TType.Struct, Addresses.Count));
             foreach (MIPAddress _iter18 in Addresses)
             {
                 _iter18.Write(oprot);
             }
             oprot.WriteListEnd();
         }
         oprot.WriteFieldEnd();
         if (Properties != null && __isset.Properties)
         {
             field.Name = "Properties";
             field.Type = TType.Map;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteMapBegin(new TMap(TType.String, TType.String, Properties.Count));
                 foreach (string _iter19 in Properties.Keys)
                 {
                     oprot.WriteString(_iter19);
                     oprot.WriteString(Properties[_iter19]);
                 }
                 oprot.WriteMapEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (Parameters != null && __isset.Parameters)
         {
             field.Name = "Parameters";
             field.Type = TType.List;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, Parameters.Count));
                 foreach (MParameter _iter20 in Parameters)
                 {
                     _iter20.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("SmartContract");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (Address == null)
         {
             throw new TProtocolException(TProtocolException.INVALID_DATA, "required field Address not set");
         }
         field.Name = "address";
         field.Type = TType.String;
         field.ID   = 1;
         oprot.WriteFieldBegin(field);
         oprot.WriteString(Address);
         oprot.WriteFieldEnd();
         if (SourceCode != null && __isset.sourceCode)
         {
             field.Name = "sourceCode";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(SourceCode);
             oprot.WriteFieldEnd();
         }
         if (ByteCode != null && __isset.byteCode)
         {
             field.Name = "byteCode";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteBinary(ByteCode);
             oprot.WriteFieldEnd();
         }
         if (ContractState != null && __isset.contractState)
         {
             field.Name = "contractState";
             field.Type = TType.String;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteBinary(ContractState);
             oprot.WriteFieldEnd();
         }
         if (HashState != null && __isset.hashState)
         {
             field.Name = "hashState";
             field.Type = TType.String;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(HashState);
             oprot.WriteFieldEnd();
         }
         if (Method != null && __isset.method)
         {
             field.Name = "method";
             field.Type = TType.String;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Method);
             oprot.WriteFieldEnd();
         }
         if (Params != null && __isset.@params)
         {
             field.Name = "params";
             field.Type = TType.List;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.String, Params.Count));
                 foreach (string _iter3 in Params)
                 {
                     oprot.WriteString(_iter3);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #5
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("QueryQuestions_args");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.courseId)
         {
             field.Name = "courseId";
             field.Type = TType.I16;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(CourseId);
             oprot.WriteFieldEnd();
         }
         if (__isset.typeId)
         {
             field.Name = "typeId";
             field.Type = TType.I16;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(TypeId);
             oprot.WriteFieldEnd();
         }
         if (__isset.diffType)
         {
             field.Name = "diffType";
             field.Type = TType.I16;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(DiffType);
             oprot.WriteFieldEnd();
         }
         if (__isset.paperTypeId)
         {
             field.Name = "paperTypeId";
             field.Type = TType.I16;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(PaperTypeId);
             oprot.WriteFieldEnd();
         }
         if (__isset.kpId)
         {
             field.Name = "kpId";
             field.Type = TType.I16;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(KpId);
             oprot.WriteFieldEnd();
         }
         if (__isset.cpId)
         {
             field.Name = "cpId";
             field.Type = TType.I16;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(CpId);
             oprot.WriteFieldEnd();
         }
         if (__isset.pageIndex)
         {
             field.Name = "pageIndex";
             field.Type = TType.I16;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(PageIndex);
             oprot.WriteFieldEnd();
         }
         if (__isset.pageSize)
         {
             field.Name = "pageSize";
             field.Type = TType.I16;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(PageSize);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("FichaAtendimentoOdontologicoChildThrift");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.dtNascimento)
         {
             field.Name = "dtNascimento";
             field.Type = TType.I64;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(DtNascimento);
             oprot.WriteFieldEnd();
         }
         if (CnsCidadao != null && __isset.cnsCidadao)
         {
             field.Name = "cnsCidadao";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(CnsCidadao);
             oprot.WriteFieldEnd();
         }
         if (NumProntuario != null && __isset.numProntuario)
         {
             field.Name = "numProntuario";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(NumProntuario);
             oprot.WriteFieldEnd();
         }
         if (__isset.gestante)
         {
             field.Name = "gestante";
             field.Type = TType.Bool;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(Gestante);
             oprot.WriteFieldEnd();
         }
         if (__isset.necessidadesEspeciais)
         {
             field.Name = "necessidadesEspeciais";
             field.Type = TType.Bool;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(NecessidadesEspeciais);
             oprot.WriteFieldEnd();
         }
         if (__isset.localAtendimento)
         {
             field.Name = "localAtendimento";
             field.Type = TType.I64;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(LocalAtendimento);
             oprot.WriteFieldEnd();
         }
         if (__isset.tipoAtendimento)
         {
             field.Name = "tipoAtendimento";
             field.Type = TType.I64;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(TipoAtendimento);
             oprot.WriteFieldEnd();
         }
         if (TiposEncamOdonto != null && __isset.tiposEncamOdonto)
         {
             field.Name = "tiposEncamOdonto";
             field.Type = TType.List;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.I64, TiposEncamOdonto.Count));
                 foreach (long _iter21 in TiposEncamOdonto)
                 {
                     oprot.WriteI64(_iter21);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (TiposFornecimOdonto != null && __isset.tiposFornecimOdonto)
         {
             field.Name = "tiposFornecimOdonto";
             field.Type = TType.List;
             field.ID   = 9;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.I64, TiposFornecimOdonto.Count));
                 foreach (long _iter22 in TiposFornecimOdonto)
                 {
                     oprot.WriteI64(_iter22);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (TiposVigilanciaSaudeBucal != null && __isset.tiposVigilanciaSaudeBucal)
         {
             field.Name = "tiposVigilanciaSaudeBucal";
             field.Type = TType.List;
             field.ID   = 10;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.I64, TiposVigilanciaSaudeBucal.Count));
                 foreach (long _iter23 in TiposVigilanciaSaudeBucal)
                 {
                     oprot.WriteI64(_iter23);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (TiposConsultaOdonto != null && __isset.tiposConsultaOdonto)
         {
             field.Name = "tiposConsultaOdonto";
             field.Type = TType.List;
             field.ID   = 11;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.I64, TiposConsultaOdonto.Count));
                 foreach (long _iter24 in TiposConsultaOdonto)
                 {
                     oprot.WriteI64(_iter24);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (ProcedimentosRealizados != null && __isset.procedimentosRealizados)
         {
             field.Name = "procedimentosRealizados";
             field.Type = TType.List;
             field.ID   = 12;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, ProcedimentosRealizados.Count));
                 foreach (ProcedimentoQuantidadeThrift _iter25 in ProcedimentosRealizados)
                 {
                     _iter25.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (__isset.sexo)
         {
             field.Name = "sexo";
             field.Type = TType.I64;
             field.ID   = 14;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Sexo);
             oprot.WriteFieldEnd();
         }
         if (__isset.turno)
         {
             field.Name = "turno";
             field.Type = TType.I64;
             field.ID   = 15;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Turno);
             oprot.WriteFieldEnd();
         }
         if (__isset.dataHoraInicialAtendimento)
         {
             field.Name = "dataHoraInicialAtendimento";
             field.Type = TType.I64;
             field.ID   = 16;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(DataHoraInicialAtendimento);
             oprot.WriteFieldEnd();
         }
         if (__isset.dataHoraFinalAtendimento)
         {
             field.Name = "dataHoraFinalAtendimento";
             field.Type = TType.I64;
             field.ID   = 17;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(DataHoraFinalAtendimento);
             oprot.WriteFieldEnd();
         }
         if (CpfCidadao != null && __isset.cpfCidadao)
         {
             field.Name = "cpfCidadao";
             field.Type = TType.String;
             field.ID   = 18;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(CpfCidadao);
             oprot.WriteFieldEnd();
         }
         if (Medicamentos != null && __isset.medicamentos)
         {
             field.Name = "medicamentos";
             field.Type = TType.List;
             field.ID   = 19;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, Medicamentos.Count));
                 foreach (br.gov.saude.esusab.ras.common.MedicamentoThrift _iter26 in Medicamentos)
                 {
                     _iter26.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (Encaminhamentos != null && __isset.encaminhamentos)
         {
             field.Name = "encaminhamentos";
             field.Type = TType.List;
             field.ID   = 20;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, Encaminhamentos.Count));
                 foreach (br.gov.saude.esusab.ras.common.EncaminhamentoExternoThrift _iter27 in Encaminhamentos)
                 {
                     _iter27.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #7
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("CompactContact");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (Mid != null && __isset.mid)
         {
             field.Name = "mid";
             field.Type = TType.String;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Mid);
             oprot.WriteFieldEnd();
         }
         if (__isset.createdTime)
         {
             field.Name = "createdTime";
             field.Type = TType.I64;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(CreatedTime);
             oprot.WriteFieldEnd();
         }
         if (__isset.modifiedTime)
         {
             field.Name = "modifiedTime";
             field.Type = TType.I64;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(ModifiedTime);
             oprot.WriteFieldEnd();
         }
         if (__isset.status)
         {
             field.Name = "status";
             field.Type = TType.I32;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Status);
             oprot.WriteFieldEnd();
         }
         if (__isset.settings)
         {
             field.Name = "settings";
             field.Type = TType.I64;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Settings);
             oprot.WriteFieldEnd();
         }
         if (DisplayNameOverridden != null && __isset.displayNameOverridden)
         {
             field.Name = "displayNameOverridden";
             field.Type = TType.String;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(DisplayNameOverridden);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("SFAction");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.id)
         {
             field.Name = "id";
             field.Type = TType.I64;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Id);
             oprot.WriteFieldEnd();
         }
         if (__isset.triggerId)
         {
             field.Name = "triggerId";
             field.Type = TType.I64;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(TriggerId);
             oprot.WriteFieldEnd();
         }
         if (__isset.type)
         {
             field.Name = "type";
             field.Type = TType.I32;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Type);
             oprot.WriteFieldEnd();
         }
         if (__isset.target)
         {
             field.Name = "target";
             field.Type = TType.I32;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Target);
             oprot.WriteFieldEnd();
         }
         if (Config != null && __isset.config)
         {
             field.Name = "config";
             field.Type = TType.Struct;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             Config.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (__isset.enabled)
         {
             field.Name = "enabled";
             field.Type = TType.Bool;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(Enabled);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("TDDISafetyStandard");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.Id)
         {
             field.Name = "Id";
             field.Type = TType.I64;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Id);
             oprot.WriteFieldEnd();
         }
         if (Name != null && __isset.Name)
         {
             field.Name = "Name";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Name);
             oprot.WriteFieldEnd();
         }
         if (Description != null && __isset.Description)
         {
             field.Name = "Description";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Description);
             oprot.WriteFieldEnd();
         }
         if (__isset.IsCitation)
         {
             field.Name = "IsCitation";
             field.Type = TType.Bool;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(IsCitation);
             oprot.WriteFieldEnd();
         }
         if (__isset.IsAbstract)
         {
             field.Name = "IsAbstract";
             field.Type = TType.Bool;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(IsAbstract);
             oprot.WriteFieldEnd();
         }
         if (KeyValueMaps != null && __isset.KeyValueMaps)
         {
             field.Name = "KeyValueMaps";
             field.Type = TType.List;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, KeyValueMaps.Count));
                 foreach (TDDIKeyValueMapRef _iter422 in KeyValueMaps)
                 {
                     _iter422.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (CitedElement != null && __isset.CitedElement)
         {
             field.Name = "CitedElement";
             field.Type = TType.Struct;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             CitedElement.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (AssuranceLevels != null && __isset.AssuranceLevels)
         {
             field.Name = "AssuranceLevels";
             field.Type = TType.List;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, AssuranceLevels.Count));
                 foreach (TDDIAssuranceLevel _iter423 in AssuranceLevels)
                 {
                     _iter423.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #10
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("MNMessagesSyncDeltaMarkUnread");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (ThreadKeys != null && __isset.ThreadKeys)
         {
             field.Name = "ThreadKeys";
             field.Type = TType.List;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, ThreadKeys.Count));
                 foreach (MNMessagesSyncThreadKey _iter53 in ThreadKeys)
                 {
                     _iter53.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (Folders != null && __isset.Folders)
         {
             field.Name = "Folders";
             field.Type = TType.List;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.I32, Folders.Count));
                 foreach (int _iter54 in Folders)
                 {
                     oprot.WriteI32(_iter54);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (__isset.WatermarkTimestamp)
         {
             field.Name = "WatermarkTimestamp";
             field.Type = TType.I64;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(WatermarkTimestamp);
             oprot.WriteFieldEnd();
         }
         if (__isset.ActionTimestamp)
         {
             field.Name = "ActionTimestamp";
             field.Type = TType.I64;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(ActionTimestamp);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #11
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("SharedNotebook");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.id)
         {
             field.Name = "id";
             field.Type = TType.I64;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Id);
             oprot.WriteFieldEnd();
         }
         if (__isset.userId)
         {
             field.Name = "userId";
             field.Type = TType.I32;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(UserId);
             oprot.WriteFieldEnd();
         }
         if (NotebookGuid != null && __isset.notebookGuid)
         {
             field.Name = "notebookGuid";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(NotebookGuid);
             oprot.WriteFieldEnd();
         }
         if (Email != null && __isset.email)
         {
             field.Name = "email";
             field.Type = TType.String;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Email);
             oprot.WriteFieldEnd();
         }
         if (__isset.notebookModifiable)
         {
             field.Name = "notebookModifiable";
             field.Type = TType.Bool;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(NotebookModifiable);
             oprot.WriteFieldEnd();
         }
         if (__isset.serviceCreated)
         {
             field.Name = "serviceCreated";
             field.Type = TType.I64;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(ServiceCreated);
             oprot.WriteFieldEnd();
         }
         if (GlobalId != null && __isset.globalId)
         {
             field.Name = "globalId";
             field.Type = TType.String;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(GlobalId);
             oprot.WriteFieldEnd();
         }
         if (Username != null && __isset.username)
         {
             field.Name = "username";
             field.Type = TType.String;
             field.ID   = 9;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Username);
             oprot.WriteFieldEnd();
         }
         if (__isset.serviceUpdated)
         {
             field.Name = "serviceUpdated";
             field.Type = TType.I64;
             field.ID   = 10;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(ServiceUpdated);
             oprot.WriteFieldEnd();
         }
         if (__isset.privilege)
         {
             field.Name = "privilege";
             field.Type = TType.I32;
             field.ID   = 11;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Privilege);
             oprot.WriteFieldEnd();
         }
         if (RecipientSettings != null && __isset.recipientSettings)
         {
             field.Name = "recipientSettings";
             field.Type = TType.Struct;
             field.ID   = 13;
             oprot.WriteFieldBegin(field);
             RecipientSettings.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (__isset.sharerUserId)
         {
             field.Name = "sharerUserId";
             field.Type = TType.I32;
             field.ID   = 14;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(SharerUserId);
             oprot.WriteFieldEnd();
         }
         if (RecipientUsername != null && __isset.recipientUsername)
         {
             field.Name = "recipientUsername";
             field.Type = TType.String;
             field.ID   = 15;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(RecipientUsername);
             oprot.WriteFieldEnd();
         }
         if (__isset.serviceAssigned)
         {
             field.Name = "serviceAssigned";
             field.Type = TType.I64;
             field.ID   = 16;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(ServiceAssigned);
             oprot.WriteFieldEnd();
         }
         if (__isset.recipientUserId)
         {
             field.Name = "recipientUserId";
             field.Type = TType.I32;
             field.ID   = 17;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(RecipientUserId);
             oprot.WriteFieldEnd();
         }
         if (__isset.recipientIdentityId)
         {
             field.Name = "recipientIdentityId";
             field.Type = TType.I64;
             field.ID   = 18;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(RecipientIdentityId);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("RoutineDTO");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (Id != null && __isset.id)
         {
             field.Name = "id";
             field.Type = TType.String;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Id);
             oprot.WriteFieldEnd();
         }
         if (__isset.privateRoutine)
         {
             field.Name = "privateRoutine";
             field.Type = TType.Bool;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(PrivateRoutine);
             oprot.WriteFieldEnd();
         }
         if (Name != null && __isset.name)
         {
             field.Name = "name";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Name);
             oprot.WriteFieldEnd();
         }
         if (Description != null && __isset.description)
         {
             field.Name = "description";
             field.Type = TType.String;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Description);
             oprot.WriteFieldEnd();
         }
         if (__isset.revision)
         {
             field.Name = "revision";
             field.Type = TType.I16;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI16(Revision);
             oprot.WriteFieldEnd();
         }
         if (__isset.type)
         {
             field.Name = "type";
             field.Type = TType.I32;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Type);
             oprot.WriteFieldEnd();
         }
         if (__isset.language)
         {
             field.Name = "language";
             field.Type = TType.I32;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Language);
             oprot.WriteFieldEnd();
         }
         if (InParameters != null && __isset.inParameters)
         {
             field.Name = "inParameters";
             field.Type = TType.List;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, InParameters.Count));
                 foreach (FormalParameterDTO _iter30 in InParameters)
                 {
                     _iter30.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (OutParameter != null && __isset.outParameter)
         {
             field.Name = "outParameter";
             field.Type = TType.Struct;
             field.ID   = 9;
             oprot.WriteFieldBegin(field);
             OutParameter.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (RoutineBinaries != null && __isset.routineBinaries)
         {
             field.Name = "routineBinaries";
             field.Type = TType.Set;
             field.ID   = 10;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteSetBegin(new TSet(TType.Struct, RoutineBinaries.Count));
                 foreach (RoutineBinaryDTO _iter31 in RoutineBinaries)
                 {
                     _iter31.Write(oprot);
                 }
                 oprot.WriteSetEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (Arguments != null && __isset.arguments)
         {
             field.Name = "arguments";
             field.Type = TType.List;
             field.ID   = 11;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.String, Arguments.Count));
                 foreach (string _iter32 in Arguments)
                 {
                     oprot.WriteString(_iter32);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #13
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("TRegionInfo");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (StartKey != null && __isset.startKey)
         {
             field.Name = "startKey";
             field.Type = TType.String;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteBinary(StartKey);
             oprot.WriteFieldEnd();
         }
         if (EndKey != null && __isset.endKey)
         {
             field.Name = "endKey";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteBinary(EndKey);
             oprot.WriteFieldEnd();
         }
         if (__isset.id)
         {
             field.Name = "id";
             field.Type = TType.I64;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Id);
             oprot.WriteFieldEnd();
         }
         if (Name != null && __isset.name)
         {
             field.Name = "name";
             field.Type = TType.String;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteBinary(Name);
             oprot.WriteFieldEnd();
         }
         if (__isset.version)
         {
             field.Name = "version";
             field.Type = TType.Byte;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteByte(Version);
             oprot.WriteFieldEnd();
         }
         if (ServerName != null && __isset.serverName)
         {
             field.Name = "serverName";
             field.Type = TType.String;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteBinary(ServerName);
             oprot.WriteFieldEnd();
         }
         if (__isset.port)
         {
             field.Name = "port";
             field.Type = TType.I32;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(Port);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #14
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("TimResponseBean");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (ThreadId != null && __isset.threadId)
         {
             field.Name = "threadId";
             field.Type = TType.String;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(ThreadId);
             oprot.WriteFieldEnd();
         }
         if (Error != null && __isset.error)
         {
             field.Name = "error";
             field.Type = TType.Struct;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             Error.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (ExtraList != null && __isset.extraList)
         {
             field.Name = "extraList";
             field.Type = TType.List;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, ExtraList.Count));
                 foreach (TimNode _iter115 in ExtraList)
                 {
                     _iter115.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (ExtraMap != null && __isset.extraMap)
         {
             field.Name = "extraMap";
             field.Type = TType.Map;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteMapBegin(new TMap(TType.String, TType.String, ExtraMap.Count));
                 foreach (string _iter116 in ExtraMap.Keys)
                 {
                     oprot.WriteString(_iter116);
                     oprot.WriteString(ExtraMap[_iter116]);
                 }
                 oprot.WriteMapEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #15
0
    public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
    {
        oprot.IncrementRecursionDepth();
        try
        {
            var struc = new TStruct("Operation");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);

            var field = new TField();
            if (__isset.revision)
            {
                field.Name = "revision";
                field.Type = TType.I64;
                field.ID   = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteI64Async(Revision, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (__isset.createdTime)
            {
                field.Name = "createdTime";
                field.Type = TType.I64;
                field.ID   = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteI64Async(CreatedTime, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (__isset.type)
            {
                field.Name = "type";
                field.Type = TType.I32;
                field.ID   = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteI32Async((int)Type, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (__isset.reqSeq)
            {
                field.Name = "reqSeq";
                field.Type = TType.I32;
                field.ID   = 4;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteI32Async(ReqSeq, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (Checksum != null && __isset.checksum)
            {
                field.Name = "checksum";
                field.Type = TType.String;
                field.ID   = 5;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteStringAsync(Checksum, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (__isset.status)
            {
                field.Name = "status";
                field.Type = TType.I32;
                field.ID   = 7;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteI32Async((int)Status, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (Param1 != null && __isset.param1)
            {
                field.Name = "param1";
                field.Type = TType.String;
                field.ID   = 10;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteStringAsync(Param1, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (Param2 != null && __isset.param2)
            {
                field.Name = "param2";
                field.Type = TType.String;
                field.ID   = 11;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteStringAsync(Param2, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (Param3 != null && __isset.param3)
            {
                field.Name = "param3";
                field.Type = TType.String;
                field.ID   = 12;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteStringAsync(Param3, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (Message != null && __isset.message)
            {
                field.Name = "message";
                field.Type = TType.Struct;
                field.ID   = 20;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await Message.WriteAsync(oprot, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            await oprot.WriteFieldStopAsync(cancellationToken);

            await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
            oprot.DecrementRecursionDepth();
        }
    }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("NoteLimits");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.noteResourceCountMax)
         {
             field.Name = "noteResourceCountMax";
             field.Type = TType.I32;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(NoteResourceCountMax);
             oprot.WriteFieldEnd();
         }
         if (__isset.uploadLimit)
         {
             field.Name = "uploadLimit";
             field.Type = TType.I64;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(UploadLimit);
             oprot.WriteFieldEnd();
         }
         if (__isset.resourceSizeMax)
         {
             field.Name = "resourceSizeMax";
             field.Type = TType.I64;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(ResourceSizeMax);
             oprot.WriteFieldEnd();
         }
         if (__isset.noteSizeMax)
         {
             field.Name = "noteSizeMax";
             field.Type = TType.I64;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(NoteSizeMax);
             oprot.WriteFieldEnd();
         }
         if (__isset.uploaded)
         {
             field.Name = "uploaded";
             field.Type = TType.I64;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Uploaded);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #17
0
        public void Write(TProtocol oprot)
        {
            var struc = new TStruct("RestRequest");

            oprot.WriteStructBegin(struc);
            var field = new TField();

            if (__isset.method)
            {
                field.Name = "method";
                field.Type = TType.I32;
                field.ID   = 1;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32((int)method);
                oprot.WriteFieldEnd();
            }
            if (uri != null && __isset.uri)
            {
                field.Name = "uri";
                field.Type = TType.String;
                field.ID   = 2;
                oprot.WriteFieldBegin(field);
                oprot.WriteString(uri);
                oprot.WriteFieldEnd();
            }
            if (parameters != null && __isset.parameters)
            {
                field.Name = "parameters";
                field.Type = TType.Map;
                field.ID   = 3;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteMapBegin(new TMap(TType.String, TType.String, parameters.Count));
                    foreach (string _iter8 in parameters.Keys)
                    {
                        oprot.WriteString(_iter8);
                        oprot.WriteString(parameters[_iter8]);
                        oprot.WriteMapEnd();
                    }
                }
                oprot.WriteFieldEnd();
            }
            if (headers != null && __isset.headers)
            {
                field.Name = "headers";
                field.Type = TType.Map;
                field.ID   = 4;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteMapBegin(new TMap(TType.String, TType.String, headers.Count));
                    foreach (string _iter9 in headers.Keys)
                    {
                        oprot.WriteString(_iter9);
                        oprot.WriteString(headers[_iter9]);
                        oprot.WriteMapEnd();
                    }
                }
                oprot.WriteFieldEnd();
            }
            if (body != null && __isset.body)
            {
                field.Name = "body";
                field.Type = TType.String;
                field.ID   = 5;
                oprot.WriteFieldBegin(field);
                oprot.WriteBinary(body);
                oprot.WriteFieldEnd();
            }
            oprot.WriteFieldStop();
            oprot.WriteStructEnd();
        }
Beispiel #18
0
        public void Write(TProtocol oprot)
        {
            TStruct struc = new TStruct("Search");

            oprot.WriteStructBegin(struc);
            TField field = new TField();

            if (__isset.stype)
            {
                field.Name = "stype";
                field.Type = TType.I32;
                field.ID   = 1;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32((int)Stype);
                oprot.WriteFieldEnd();
            }
            if (Query != null && __isset.query)
            {
                field.Name = "query";
                field.Type = TType.String;
                field.ID   = 2;
                oprot.WriteFieldBegin(field);
                oprot.WriteString(Query);
                oprot.WriteFieldEnd();
            }
            if (Conditions != null && __isset.conditions)
            {
                field.Name = "conditions";
                field.Type = TType.List;
                field.ID   = 3;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.Struct, Conditions.Count));
                    foreach (Condition _iter7 in Conditions)
                    {
                        _iter7.Write(oprot);
                    }
                    oprot.WriteListEnd();
                }
                oprot.WriteFieldEnd();
            }
            if (__isset.startYear)
            {
                field.Name = "startYear";
                field.Type = TType.I32;
                field.ID   = 4;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(StartYear);
                oprot.WriteFieldEnd();
            }
            if (__isset.endYear)
            {
                field.Name = "endYear";
                field.Type = TType.I32;
                field.ID   = 5;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(EndYear);
                oprot.WriteFieldEnd();
            }
            if (__isset.language)
            {
                field.Name = "language";
                field.Type = TType.I32;
                field.ID   = 6;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32((int)Language);
                oprot.WriteFieldEnd();
            }
            if (__isset.page)
            {
                field.Name = "page";
                field.Type = TType.I32;
                field.ID   = 7;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(Page);
                oprot.WriteFieldEnd();
            }
            if (__isset.size)
            {
                field.Name = "size";
                field.Type = TType.I32;
                field.ID   = 8;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(Size);
                oprot.WriteFieldEnd();
            }
            if (__isset.highlight)
            {
                field.Name = "highlight";
                field.Type = TType.Bool;
                field.ID   = 9;
                oprot.WriteFieldBegin(field);
                oprot.WriteBool(Highlight);
                oprot.WriteFieldEnd();
            }
            oprot.WriteFieldStop();
            oprot.WriteStructEnd();
        }
Beispiel #19
0
        public void Write(TProtocol oprot)
        {
            TStruct struc = new TStruct("StorageDescriptor");

            oprot.WriteStructBegin(struc);
            TField field = new TField();

            if (Cols != null && __isset.cols)
            {
                field.Name = "cols";
                field.Type = TType.List;
                field.ID   = 1;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.Struct, Cols.Count));
                    foreach (FieldSchema _iter91 in Cols)
                    {
                        _iter91.Write(oprot);
                    }
                    oprot.WriteListEnd();
                }
                oprot.WriteFieldEnd();
            }
            if (Location != null && __isset.location)
            {
                field.Name = "location";
                field.Type = TType.String;
                field.ID   = 2;
                oprot.WriteFieldBegin(field);
                oprot.WriteString(Location);
                oprot.WriteFieldEnd();
            }
            if (InputFormat != null && __isset.inputFormat)
            {
                field.Name = "inputFormat";
                field.Type = TType.String;
                field.ID   = 3;
                oprot.WriteFieldBegin(field);
                oprot.WriteString(InputFormat);
                oprot.WriteFieldEnd();
            }
            if (OutputFormat != null && __isset.outputFormat)
            {
                field.Name = "outputFormat";
                field.Type = TType.String;
                field.ID   = 4;
                oprot.WriteFieldBegin(field);
                oprot.WriteString(OutputFormat);
                oprot.WriteFieldEnd();
            }
            if (__isset.compressed)
            {
                field.Name = "compressed";
                field.Type = TType.Bool;
                field.ID   = 5;
                oprot.WriteFieldBegin(field);
                oprot.WriteBool(Compressed);
                oprot.WriteFieldEnd();
            }
            if (__isset.numBuckets)
            {
                field.Name = "numBuckets";
                field.Type = TType.I32;
                field.ID   = 6;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(NumBuckets);
                oprot.WriteFieldEnd();
            }
            if (SerdeInfo != null && __isset.serdeInfo)
            {
                field.Name = "serdeInfo";
                field.Type = TType.Struct;
                field.ID   = 7;
                oprot.WriteFieldBegin(field);
                SerdeInfo.Write(oprot);
                oprot.WriteFieldEnd();
            }
            if (BucketCols != null && __isset.bucketCols)
            {
                field.Name = "bucketCols";
                field.Type = TType.List;
                field.ID   = 8;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.String, BucketCols.Count));
                    foreach (string _iter92 in BucketCols)
                    {
                        oprot.WriteString(_iter92);
                    }
                    oprot.WriteListEnd();
                }
                oprot.WriteFieldEnd();
            }
            if (SortCols != null && __isset.sortCols)
            {
                field.Name = "sortCols";
                field.Type = TType.List;
                field.ID   = 9;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.Struct, SortCols.Count));
                    foreach (Order _iter93 in SortCols)
                    {
                        _iter93.Write(oprot);
                    }
                    oprot.WriteListEnd();
                }
                oprot.WriteFieldEnd();
            }
            if (Parameters != null && __isset.parameters)
            {
                field.Name = "parameters";
                field.Type = TType.Map;
                field.ID   = 10;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteMapBegin(new TMap(TType.String, TType.String, Parameters.Count));
                    foreach (string _iter94 in Parameters.Keys)
                    {
                        oprot.WriteString(_iter94);
                        oprot.WriteString(Parameters[_iter94]);
                    }
                    oprot.WriteMapEnd();
                }
                oprot.WriteFieldEnd();
            }
            if (SkewedInfo != null && __isset.skewedInfo)
            {
                field.Name = "skewedInfo";
                field.Type = TType.Struct;
                field.ID   = 11;
                oprot.WriteFieldBegin(field);
                SkewedInfo.Write(oprot);
                oprot.WriteFieldEnd();
            }
            if (__isset.storedAsSubDirectories)
            {
                field.Name = "storedAsSubDirectories";
                field.Type = TType.Bool;
                field.ID   = 12;
                oprot.WriteFieldBegin(field);
                oprot.WriteBool(StoredAsSubDirectories);
                oprot.WriteFieldEnd();
            }
            oprot.WriteFieldStop();
            oprot.WriteStructEnd();
        }
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("TDDIArtifactElementUnion");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (TerminologyElement != null && __isset.TerminologyElement)
         {
             field.Name = "TerminologyElement";
             field.Type = TType.Struct;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             TerminologyElement.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (AssuranceCasePackage != null && __isset.AssuranceCasePackage)
         {
             field.Name = "AssuranceCasePackage";
             field.Type = TType.Struct;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             AssuranceCasePackage.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (ArtifactPackage != null && __isset.ArtifactPackage)
         {
             field.Name = "ArtifactPackage";
             field.Type = TType.Struct;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             ArtifactPackage.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (ArtifactGroup != null && __isset.ArtifactGroup)
         {
             field.Name = "ArtifactGroup";
             field.Type = TType.Struct;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             ArtifactGroup.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (ArtifactAsset != null && __isset.ArtifactAsset)
         {
             field.Name = "ArtifactAsset";
             field.Type = TType.Struct;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             ArtifactAsset.Write(oprot);
             oprot.WriteFieldEnd();
         }
         if (ArgumentationElement != null && __isset.ArgumentationElement)
         {
             field.Name = "ArgumentationElement";
             field.Type = TType.Struct;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             ArgumentationElement.Write(oprot);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
        public void Write(TProtocol oprot)
        {
            TStruct struc = new TStruct("PlayerProcessInfo");

            oprot.WriteStructBegin(struc);
            TField field = new TField();

            if (__isset.stageType)
            {
                field.Name = "stageType";
                field.Type = TType.I32;
                field.ID   = 10;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(StageType);
                oprot.WriteFieldEnd();
            }
            if (__isset.terrainDataType)
            {
                field.Name = "terrainDataType";
                field.Type = TType.I32;
                field.ID   = 11;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(TerrainDataType);
                oprot.WriteFieldEnd();
            }
            if (PlayerTransformInfo != null && __isset.playerTransformInfo)
            {
                field.Name = "playerTransformInfo";
                field.Type = TType.Struct;
                field.ID   = 20;
                oprot.WriteFieldBegin(field);
                PlayerTransformInfo.Write(oprot);
                oprot.WriteFieldEnd();
            }
            if (__isset.isResumeScene)
            {
                field.Name = "isResumeScene";
                field.Type = TType.Bool;
                field.ID   = 30;
                oprot.WriteFieldBegin(field);
                oprot.WriteBool(IsResumeScene);
                oprot.WriteFieldEnd();
            }
            if (__isset.actionId)
            {
                field.Name = "actionId";
                field.Type = TType.I32;
                field.ID   = 40;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(ActionId);
                oprot.WriteFieldEnd();
            }
            if (__isset.exitSceneFuncId)
            {
                field.Name = "exitSceneFuncId";
                field.Type = TType.I32;
                field.ID   = 50;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(ExitSceneFuncId);
                oprot.WriteFieldEnd();
            }
            if (__isset.exitSceneStep2FuncId)
            {
                field.Name = "exitSceneStep2FuncId";
                field.Type = TType.I32;
                field.ID   = 51;
                oprot.WriteFieldBegin(field);
                oprot.WriteI32(ExitSceneStep2FuncId);
                oprot.WriteFieldEnd();
            }
            if (NpcTransformInfoList != null && __isset.npcTransformInfoList)
            {
                field.Name = "npcTransformInfoList";
                field.Type = TType.Map;
                field.ID   = 60;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteMapBegin(new TMap(TType.I32, TType.Struct, NpcTransformInfoList.Count));
                    foreach (int _iter16 in NpcTransformInfoList.Keys)
                    {
                        oprot.WriteI32(_iter16);
                        NpcTransformInfoList[_iter16].Write(oprot);
                    }
                    oprot.WriteMapEnd();
                }
                oprot.WriteFieldEnd();
            }
            oprot.WriteFieldStop();
            oprot.WriteStructEnd();
        }
Beispiel #22
0
        public void Write(TProtocol oprot)
        {
            TStruct struc = new TStruct("RelatedResult");

            oprot.WriteStructBegin(struc);
            TField field = new TField();

            if (Notes != null && __isset.notes)
            {
                field.Name = "notes";
                field.Type = TType.List;
                field.ID   = 1;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.Struct, Notes.Count));
                    foreach (Evernote.EDAM.Type.Note _iter106 in Notes)
                    {
                        _iter106.Write(oprot);
                        oprot.WriteListEnd();
                    }
                }
                oprot.WriteFieldEnd();
            }
            if (Notebooks != null && __isset.notebooks)
            {
                field.Name = "notebooks";
                field.Type = TType.List;
                field.ID   = 2;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.Struct, Notebooks.Count));
                    foreach (Evernote.EDAM.Type.Notebook _iter107 in Notebooks)
                    {
                        _iter107.Write(oprot);
                        oprot.WriteListEnd();
                    }
                }
                oprot.WriteFieldEnd();
            }
            if (Tags != null && __isset.tags)
            {
                field.Name = "tags";
                field.Type = TType.List;
                field.ID   = 3;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.Struct, Tags.Count));
                    foreach (Evernote.EDAM.Type.Tag _iter108 in Tags)
                    {
                        _iter108.Write(oprot);
                        oprot.WriteListEnd();
                    }
                }
                oprot.WriteFieldEnd();
            }
            if (ContainingNotebooks != null && __isset.containingNotebooks)
            {
                field.Name = "containingNotebooks";
                field.Type = TType.List;
                field.ID   = 4;
                oprot.WriteFieldBegin(field);
                {
                    oprot.WriteListBegin(new TList(TType.Struct, ContainingNotebooks.Count));
                    foreach (Evernote.EDAM.Type.NotebookDescriptor _iter109 in ContainingNotebooks)
                    {
                        _iter109.Write(oprot);
                        oprot.WriteListEnd();
                    }
                }
                oprot.WriteFieldEnd();
            }
            oprot.WriteFieldStop();
            oprot.WriteStructEnd();
        }
Beispiel #23
0
    public void Write(TProtocol oprot)
    {
        TStruct struc = new TStruct("Grouping");

        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (Fields != null && __isset.fields)
        {
            field.Name = "fields";
            field.Type = TType.List;
            field.ID   = 1;
            oprot.WriteFieldBegin(field);
            {
                oprot.WriteListBegin(new TList(TType.String, Fields.Count));
                foreach (string _iter7 in Fields)
                {
                    oprot.WriteString(_iter7);
                }
                oprot.WriteListEnd();
            }
            oprot.WriteFieldEnd();
        }
        if (Shuffle != null && __isset.shuffle)
        {
            field.Name = "shuffle";
            field.Type = TType.Struct;
            field.ID   = 2;
            oprot.WriteFieldBegin(field);
            Shuffle.Write(oprot);
            oprot.WriteFieldEnd();
        }
        if (All != null && __isset.all)
        {
            field.Name = "all";
            field.Type = TType.Struct;
            field.ID   = 3;
            oprot.WriteFieldBegin(field);
            All.Write(oprot);
            oprot.WriteFieldEnd();
        }
        if (None != null && __isset.none)
        {
            field.Name = "none";
            field.Type = TType.Struct;
            field.ID   = 4;
            oprot.WriteFieldBegin(field);
            None.Write(oprot);
            oprot.WriteFieldEnd();
        }
        if (Direct != null && __isset.direct)
        {
            field.Name = "direct";
            field.Type = TType.Struct;
            field.ID   = 5;
            oprot.WriteFieldBegin(field);
            Direct.Write(oprot);
            oprot.WriteFieldEnd();
        }
        if (Custom_object != null && __isset.custom_object)
        {
            field.Name = "custom_object";
            field.Type = TType.Struct;
            field.ID   = 6;
            oprot.WriteFieldBegin(field);
            Custom_object.Write(oprot);
            oprot.WriteFieldEnd();
        }
        if (Custom_serialized != null && __isset.custom_serialized)
        {
            field.Name = "custom_serialized";
            field.Type = TType.String;
            field.ID   = 7;
            oprot.WriteFieldBegin(field);
            oprot.WriteBinary(Custom_serialized);
            oprot.WriteFieldEnd();
        }
        if (Local_or_shuffle != null && __isset.local_or_shuffle)
        {
            field.Name = "local_or_shuffle";
            field.Type = TType.Struct;
            field.ID   = 8;
            oprot.WriteFieldBegin(field);
            Local_or_shuffle.Write(oprot);
            oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
    }
Beispiel #24
0
        public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
            oprot.IncrementRecursionDepth();
            try
            {
                var struc = new TStruct("ColumnChunk");
                await oprot.WriteStructBeginAsync(struc, cancellationToken);

                var field = new TField();
                if (File_path != null && __isset.file_path)
                {
                    field.Name = "file_path";
                    field.Type = TType.String;
                    field.ID   = 1;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    await oprot.WriteStringAsync(File_path, cancellationToken);

                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                field.Name = "file_offset";
                field.Type = TType.I64;
                field.ID   = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteI64Async(File_offset, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);

                if (Meta_data != null && __isset.meta_data)
                {
                    field.Name = "meta_data";
                    field.Type = TType.Struct;
                    field.ID   = 3;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    await Meta_data.WriteAsync(oprot, cancellationToken);

                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                if (__isset.offset_index_offset)
                {
                    field.Name = "offset_index_offset";
                    field.Type = TType.I64;
                    field.ID   = 4;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    await oprot.WriteI64Async(Offset_index_offset, cancellationToken);

                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                if (__isset.offset_index_length)
                {
                    field.Name = "offset_index_length";
                    field.Type = TType.I32;
                    field.ID   = 5;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    await oprot.WriteI32Async(Offset_index_length, cancellationToken);

                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                if (__isset.column_index_offset)
                {
                    field.Name = "column_index_offset";
                    field.Type = TType.I64;
                    field.ID   = 6;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    await oprot.WriteI64Async(Column_index_offset, cancellationToken);

                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                if (__isset.column_index_length)
                {
                    field.Name = "column_index_length";
                    field.Type = TType.I32;
                    field.ID   = 7;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    await oprot.WriteI32Async(Column_index_length, cancellationToken);

                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                await oprot.WriteFieldStopAsync(cancellationToken);

                await oprot.WriteStructEndAsync(cancellationToken);
            }
            finally
            {
                oprot.DecrementRecursionDepth();
            }
        }
Beispiel #25
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("EmSituacaoDeRuaThrift");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (GrauParentescoFamiliarFrequentado != null && __isset.grauParentescoFamiliarFrequentado)
         {
             field.Name = "grauParentescoFamiliarFrequentado";
             field.Type = TType.String;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(GrauParentescoFamiliarFrequentado);
             oprot.WriteFieldEnd();
         }
         if (HigienePessoalSituacaoRua != null && __isset.higienePessoalSituacaoRua)
         {
             field.Name = "higienePessoalSituacaoRua";
             field.Type = TType.List;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.I64, HigienePessoalSituacaoRua.Count));
                 foreach (long _iter18 in HigienePessoalSituacaoRua)
                 {
                     oprot.WriteI64(_iter18);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (OrigemAlimentoSituacaoRua != null && __isset.origemAlimentoSituacaoRua)
         {
             field.Name = "origemAlimentoSituacaoRua";
             field.Type = TType.List;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.I64, OrigemAlimentoSituacaoRua.Count));
                 foreach (long _iter19 in OrigemAlimentoSituacaoRua)
                 {
                     oprot.WriteI64(_iter19);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (OutraInstituicaoQueAcompanha != null && __isset.outraInstituicaoQueAcompanha)
         {
             field.Name = "outraInstituicaoQueAcompanha";
             field.Type = TType.String;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(OutraInstituicaoQueAcompanha);
             oprot.WriteFieldEnd();
         }
         if (__isset.quantidadeAlimentacoesAoDiaSituacaoRua)
         {
             field.Name = "quantidadeAlimentacoesAoDiaSituacaoRua";
             field.Type = TType.I64;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(QuantidadeAlimentacoesAoDiaSituacaoRua);
             oprot.WriteFieldEnd();
         }
         if (__isset.statusAcompanhadoPorOutraInstituicao)
         {
             field.Name = "statusAcompanhadoPorOutraInstituicao";
             field.Type = TType.Bool;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(StatusAcompanhadoPorOutraInstituicao);
             oprot.WriteFieldEnd();
         }
         if (__isset.statusPossuiReferenciaFamiliar)
         {
             field.Name = "statusPossuiReferenciaFamiliar";
             field.Type = TType.Bool;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(StatusPossuiReferenciaFamiliar);
             oprot.WriteFieldEnd();
         }
         if (__isset.statusRecebeBeneficio)
         {
             field.Name = "statusRecebeBeneficio";
             field.Type = TType.Bool;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(StatusRecebeBeneficio);
             oprot.WriteFieldEnd();
         }
         if (__isset.statusSituacaoRua)
         {
             field.Name = "statusSituacaoRua";
             field.Type = TType.Bool;
             field.ID   = 9;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(StatusSituacaoRua);
             oprot.WriteFieldEnd();
         }
         if (__isset.statusTemAcessoHigienePessoalSituacaoRua)
         {
             field.Name = "statusTemAcessoHigienePessoalSituacaoRua";
             field.Type = TType.Bool;
             field.ID   = 10;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(StatusTemAcessoHigienePessoalSituacaoRua);
             oprot.WriteFieldEnd();
         }
         if (__isset.statusVisitaFamiliarFrequentemente)
         {
             field.Name = "statusVisitaFamiliarFrequentemente";
             field.Type = TType.Bool;
             field.ID   = 11;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(StatusVisitaFamiliarFrequentemente);
             oprot.WriteFieldEnd();
         }
         if (__isset.tempoSituacaoRua)
         {
             field.Name = "tempoSituacaoRua";
             field.Type = TType.I64;
             field.ID   = 12;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(TempoSituacaoRua);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
Beispiel #26
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("TDDIAttackerGoal");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (__isset.Id)
         {
             field.Name = "Id";
             field.Type = TType.I64;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteI64(Id);
             oprot.WriteFieldEnd();
         }
         if (Name != null && __isset.Name)
         {
             field.Name = "Name";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Name);
             oprot.WriteFieldEnd();
         }
         if (Description != null && __isset.Description)
         {
             field.Name = "Description";
             field.Type = TType.String;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Description);
             oprot.WriteFieldEnd();
         }
         if (KeyValueMaps != null && __isset.KeyValueMaps)
         {
             field.Name = "KeyValueMaps";
             field.Type = TType.List;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, KeyValueMaps.Count));
                 foreach (TDDIKeyValueMap _iter1480 in KeyValueMaps)
                 {
                     _iter1480.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (Category != null && __isset.Category)
         {
             field.Name = "Category";
             field.Type = TType.String;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(Category);
             oprot.WriteFieldEnd();
         }
         if (Attacks != null && __isset.Attacks)
         {
             field.Name = "Attacks";
             field.Type = TType.List;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, Attacks.Count));
                 foreach (TDDIAbstractAttack _iter1481 in Attacks)
                 {
                     _iter1481.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (AddressedBy != null && __isset.AddressedBy)
         {
             field.Name = "AddressedBy";
             field.Type = TType.List;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, AddressedBy.Count));
                 foreach (TDDISecurityCapability _iter1482 in AddressedBy)
                 {
                     _iter1482.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         if (AttackedItems != null && __isset.AttackedItems)
         {
             field.Name = "AttackedItems";
             field.Type = TType.List;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             {
                 oprot.WriteListBegin(new TList(TType.Struct, AttackedItems.Count));
                 foreach (TDDIVulnerableItemRef _iter1483 in AttackedItems)
                 {
                     _iter1483.Write(oprot);
                 }
                 oprot.WriteListEnd();
             }
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }
        public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
        {
            oprot.IncrementRecursionDepth();
            try
            {
                var struc = new TStruct("TOpenSessionResp");
                await oprot.WriteStructBeginAsync(struc, cancellationToken);

                var field = new TField();
                field.Name = "status";
                field.Type = TType.Struct;
                field.ID   = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await Status.WriteAsync(oprot, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);

                field.Name = "serverProtocolVersion";
                field.Type = TType.I32;
                field.ID   = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await oprot.WriteI32Async((int)ServerProtocolVersion, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);

                if (SessionHandle != null && __isset.sessionHandle)
                {
                    field.Name = "sessionHandle";
                    field.Type = TType.Struct;
                    field.ID   = 3;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    await SessionHandle.WriteAsync(oprot, cancellationToken);

                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                if (Configuration != null && __isset.configuration)
                {
                    field.Name = "configuration";
                    field.Type = TType.Map;
                    field.ID   = 4;
                    await oprot.WriteFieldBeginAsync(field, cancellationToken);

                    {
                        await oprot.WriteMapBeginAsync(new TMap(TType.String, TType.String, Configuration.Count), cancellationToken);

                        foreach (string _iter80 in Configuration.Keys)
                        {
                            await oprot.WriteStringAsync(_iter80, cancellationToken);

                            await oprot.WriteStringAsync(Configuration[_iter80], cancellationToken);
                        }
                        await oprot.WriteMapEndAsync(cancellationToken);
                    }
                    await oprot.WriteFieldEndAsync(cancellationToken);
                }
                await oprot.WriteFieldStopAsync(cancellationToken);

                await oprot.WriteStructEndAsync(cancellationToken);
            }
            finally
            {
                oprot.DecrementRecursionDepth();
            }
        }
Beispiel #28
0
    public async Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
    {
        oprot.IncrementRecursionDepth();
        try
        {
            var struc = new TStruct("FindSquareByInvitationTicketResponse");
            await oprot.WriteStructBeginAsync(struc, cancellationToken);

            var field = new TField();
            if (Square != null && __isset.square)
            {
                field.Name = "square";
                field.Type = TType.Struct;
                field.ID   = 1;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await Square.WriteAsync(oprot, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (MyMembership != null && __isset.myMembership)
            {
                field.Name = "myMembership";
                field.Type = TType.Struct;
                field.ID   = 2;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await MyMembership.WriteAsync(oprot, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (SquareAuthority != null && __isset.squareAuthority)
            {
                field.Name = "squareAuthority";
                field.Type = TType.Struct;
                field.ID   = 3;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await SquareAuthority.WriteAsync(oprot, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            if (SquareStatus != null && __isset.squareStatus)
            {
                field.Name = "squareStatus";
                field.Type = TType.Struct;
                field.ID   = 4;
                await oprot.WriteFieldBeginAsync(field, cancellationToken);

                await SquareStatus.WriteAsync(oprot, cancellationToken);

                await oprot.WriteFieldEndAsync(cancellationToken);
            }
            await oprot.WriteFieldStopAsync(cancellationToken);

            await oprot.WriteStructEndAsync(cancellationToken);
        }
        finally
        {
            oprot.DecrementRecursionDepth();
        }
    }
 public void Write(TProtocol oprot) {
   TStruct struc = new TStruct("TopologyStats");
   oprot.WriteStructBegin(struc);
   TField field = new TField();
   if (Window_to_emitted != null && __isset.window_to_emitted) {
     field.Name = "window_to_emitted";
     field.Type = TType.Map;
     field.ID = 1;
     oprot.WriteFieldBegin(field);
     {
       oprot.WriteMapBegin(new TMap(TType.String, TType.I64, Window_to_emitted.Count));
       foreach (string _iter196 in Window_to_emitted.Keys)
       {
         oprot.WriteString(_iter196);
         oprot.WriteI64(Window_to_emitted[_iter196]);
       }
       oprot.WriteMapEnd();
     }
     oprot.WriteFieldEnd();
   }
   if (Window_to_transferred != null && __isset.window_to_transferred) {
     field.Name = "window_to_transferred";
     field.Type = TType.Map;
     field.ID = 2;
     oprot.WriteFieldBegin(field);
     {
       oprot.WriteMapBegin(new TMap(TType.String, TType.I64, Window_to_transferred.Count));
       foreach (string _iter197 in Window_to_transferred.Keys)
       {
         oprot.WriteString(_iter197);
         oprot.WriteI64(Window_to_transferred[_iter197]);
       }
       oprot.WriteMapEnd();
     }
     oprot.WriteFieldEnd();
   }
   if (Window_to_complete_latencies_ms != null && __isset.window_to_complete_latencies_ms) {
     field.Name = "window_to_complete_latencies_ms";
     field.Type = TType.Map;
     field.ID = 3;
     oprot.WriteFieldBegin(field);
     {
       oprot.WriteMapBegin(new TMap(TType.String, TType.Double, Window_to_complete_latencies_ms.Count));
       foreach (string _iter198 in Window_to_complete_latencies_ms.Keys)
       {
         oprot.WriteString(_iter198);
         oprot.WriteDouble(Window_to_complete_latencies_ms[_iter198]);
       }
       oprot.WriteMapEnd();
     }
     oprot.WriteFieldEnd();
   }
   if (Window_to_acked != null && __isset.window_to_acked) {
     field.Name = "window_to_acked";
     field.Type = TType.Map;
     field.ID = 4;
     oprot.WriteFieldBegin(field);
     {
       oprot.WriteMapBegin(new TMap(TType.String, TType.I64, Window_to_acked.Count));
       foreach (string _iter199 in Window_to_acked.Keys)
       {
         oprot.WriteString(_iter199);
         oprot.WriteI64(Window_to_acked[_iter199]);
       }
       oprot.WriteMapEnd();
     }
     oprot.WriteFieldEnd();
   }
   if (Window_to_failed != null && __isset.window_to_failed) {
     field.Name = "window_to_failed";
     field.Type = TType.Map;
     field.ID = 5;
     oprot.WriteFieldBegin(field);
     {
       oprot.WriteMapBegin(new TMap(TType.String, TType.I64, Window_to_failed.Count));
       foreach (string _iter200 in Window_to_failed.Keys)
       {
         oprot.WriteString(_iter200);
         oprot.WriteI64(Window_to_failed[_iter200]);
       }
       oprot.WriteMapEnd();
     }
     oprot.WriteFieldEnd();
   }
   oprot.WriteFieldStop();
   oprot.WriteStructEnd();
 }
Beispiel #30
0
 public void Write(TProtocol oprot)
 {
     oprot.IncrementRecursionDepth();
     try
     {
         TStruct struc = new TStruct("RuyiKeyboardInput");
         oprot.WriteStructBegin(struc);
         TField field = new TField();
         if (DeviceId != null && __isset.DeviceId)
         {
             field.Name = "DeviceId";
             field.Type = TType.String;
             field.ID   = 1;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(DeviceId);
             oprot.WriteFieldEnd();
         }
         if (UserId != null && __isset.UserId)
         {
             field.Name = "UserId";
             field.Type = TType.String;
             field.ID   = 2;
             oprot.WriteFieldBegin(field);
             oprot.WriteString(UserId);
             oprot.WriteFieldEnd();
         }
         if (__isset.RawOffset)
         {
             field.Name = "RawOffset";
             field.Type = TType.I32;
             field.ID   = 3;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(RawOffset);
             oprot.WriteFieldEnd();
         }
         if (__isset.@Value)
         {
             field.Name = "Value";
             field.Type = TType.I32;
             field.ID   = 4;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(Value);
             oprot.WriteFieldEnd();
         }
         if (__isset.Timestamp)
         {
             field.Name = "Timestamp";
             field.Type = TType.I32;
             field.ID   = 5;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(Timestamp);
             oprot.WriteFieldEnd();
         }
         if (__isset.Sequence)
         {
             field.Name = "Sequence";
             field.Type = TType.I32;
             field.ID   = 6;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32(Sequence);
             oprot.WriteFieldEnd();
         }
         if (__isset.Key)
         {
             field.Name = "Key";
             field.Type = TType.I32;
             field.ID   = 7;
             oprot.WriteFieldBegin(field);
             oprot.WriteI32((int)Key);
             oprot.WriteFieldEnd();
         }
         if (__isset.IsPressed)
         {
             field.Name = "IsPressed";
             field.Type = TType.Bool;
             field.ID   = 8;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(IsPressed);
             oprot.WriteFieldEnd();
         }
         if (__isset.IsReleased)
         {
             field.Name = "IsReleased";
             field.Type = TType.Bool;
             field.ID   = 9;
             oprot.WriteFieldBegin(field);
             oprot.WriteBool(IsReleased);
             oprot.WriteFieldEnd();
         }
         oprot.WriteFieldStop();
         oprot.WriteStructEnd();
     }
     finally
     {
         oprot.DecrementRecursionDepth();
     }
 }