WebSVN – SmartDukaan – Diff – /trunk/ThriftConfig/src/in/shop2020/model/v1/user/UserContextService.java

     public User authenticateUser(String email, String password) throws AuthenticationException, TException;
     public boolean userExists(String email) throws UserContextException, TException;
-    public boolean addAddressForUser(long userId, Address address, long timestamp, boolean setDefault) throws UserContextException, TException;
+    public long addAddressForUser(long userId, Address address, boolean setDefault) throws UserContextException, TException;
     public boolean removeAddressForUser(long userid, long addressId) throws UserContextException, TException;
     public boolean setUserAsLoggedIn(long userId, long timestamp) throws UserContextException, TException;
         throw result.ucx;
+      }
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
+    }
-    public boolean addAddressForUser(long userId, Address address, long timestamp, boolean setDefault) throws UserContextException, TException
+    public long addAddressForUser(long userId, Address address, boolean setDefault) throws UserContextException, TException
+    {
-      send_addAddressForUser(userId, address, timestamp, setDefault);
+      send_addAddressForUser(userId, address, setDefault);
       return recv_addAddressForUser();
+    }
-    public void send_addAddressForUser(long userId, Address address, long timestamp, boolean setDefault) throws TException
+    public void send_addAddressForUser(long userId, Address address, boolean setDefault) throws TException
+    {
       oprot_.writeMessageBegin(new TMessage("addAddressForUser", TMessageType.CALL, seqid_));
       addAddressForUser_args args = new addAddressForUser_args();
       args.userId = userId;
       args.address = address;
-      args.timestamp = timestamp;
       args.setDefault = setDefault;
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
-    public boolean recv_addAddressForUser() throws UserContextException, TException
+    public long recv_addAddressForUser() throws UserContextException, TException
+    {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
         TApplicationException x = TApplicationException.read(iprot_);
         iprot_.readMessageEnd();
         addAddressForUser_args args = new addAddressForUser_args();
         args.read(iprot);
         iprot.readMessageEnd();
         addAddressForUser_result result = new addAddressForUser_result();
         try {
-          result.success = iface_.addAddressForUser(args.userId, args.address, args.timestamp, args.setDefault);
+          result.success = iface_.addAddressForUser(args.userId, args.address, args.setDefault);
           result.setSuccessIsSet(true);
         } catch (UserContextException ucx) {
           result.ucx = ucx;
         } catch (Throwable th) {
           LOGGER.error("Internal error processing addAddressForUser", th);
       // check for required fields
+    }
+  }
-  public static class createAnonymousUser_result implements TBase<createAnonymousUser_result._Fields>, java.io.Serializable, Cloneable   {
+  public static class createAnonymousUser_result implements TBase<createAnonymousUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<createAnonymousUser_result>   {
     private static final TStruct STRUCT_DESC = new TStruct("createAnonymousUser_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
     private static final TField UCEX_FIELD_DESC = new TField("ucex", TType.STRUCT, (short)1);
     @Override
     public int hashCode() {
       return 0;
+    }
+    public int compareTo(createAnonymousUser_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createAnonymousUser_result typedOther = (createAnonymousUser_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUcex()).compareTo(isSetUcex());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(ucex, typedOther.ucex);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
       // check for required fields
+    }
+  }
-  public static class getUserById_result implements TBase<getUserById_result._Fields>, java.io.Serializable, Cloneable   {
+  public static class getUserById_result implements TBase<getUserById_result._Fields>, java.io.Serializable, Cloneable, Comparable<getUserById_result>   {
     private static final TStruct STRUCT_DESC = new TStruct("getUserById_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
     private static final TField UCEX_FIELD_DESC = new TField("ucex", TType.STRUCT, (short)1);
     @Override
     public int hashCode() {
       return 0;
+    }
+    public int compareTo(getUserById_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getUserById_result typedOther = (getUserById_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUcex()).compareTo(isSetUcex());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(ucex, typedOther.ucex);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
       // check for required fields
+    }
+  }
-  public static class createUser_args implements TBase<createUser_args._Fields>, java.io.Serializable, Cloneable   {
+  public static class createUser_args implements TBase<createUser_args._Fields>, java.io.Serializable, Cloneable, Comparable<createUser_args>   {
     private static final TStruct STRUCT_DESC = new TStruct("createUser_args");
     private static final TField USER_FIELD_DESC = new TField("user", TType.STRUCT, (short)1);
     private User user;
     @Override
     public int hashCode() {
       return 0;
+    }
+    public int compareTo(createUser_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createUser_args typedOther = (createUser_args)other;
+      lastComparison = Boolean.valueOf(isSetUser()).compareTo(isSetUser());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(user, typedOther.user);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
       // check for required fields
+    }
+  }
-  public static class createUser_result implements TBase<createUser_result._Fields>, java.io.Serializable, Cloneable   {
+  public static class createUser_result implements TBase<createUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<createUser_result>   {
     private static final TStruct STRUCT_DESC = new TStruct("createUser_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
     private static final TField UCEX_FIELD_DESC = new TField("ucex", TType.STRUCT, (short)1);
     @Override
     public int hashCode() {
       return 0;
+    }
+    public int compareTo(createUser_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createUser_result typedOther = (createUser_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUcex()).compareTo(isSetUcex());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(ucex, typedOther.ucex);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
       // check for required fields
+    }
+  }
-  public static class updateUser_args implements TBase<updateUser_args._Fields>, java.io.Serializable, Cloneable   {
+  public static class updateUser_args implements TBase<updateUser_args._Fields>, java.io.Serializable, Cloneable, Comparable<updateUser_args>   {
     private static final TStruct STRUCT_DESC = new TStruct("updateUser_args");
     private static final TField USER_FIELD_DESC = new TField("user", TType.STRUCT, (short)1);
     private User user;
     @Override
     public int hashCode() {
       return 0;
+    }
+    public int compareTo(updateUser_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      updateUser_args typedOther = (updateUser_args)other;
+      lastComparison = Boolean.valueOf(isSetUser()).compareTo(isSetUser());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(user, typedOther.user);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
       // check for required fields
+    }
+  }
-  public static class updateUser_result implements TBase<updateUser_result._Fields>, java.io.Serializable, Cloneable   {
+  public static class updateUser_result implements TBase<updateUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<updateUser_result>   {
     private static final TStruct STRUCT_DESC = new TStruct("updateUser_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
     private static final TField UCEX_FIELD_DESC = new TField("ucex", TType.STRUCT, (short)1);
     @Override
     public int hashCode() {
       return 0;
+    }
+    public int compareTo(updateUser_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      updateUser_result typedOther = (updateUser_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUcex()).compareTo(isSetUcex());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(ucex, typedOther.ucex);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
       // check for required fields
+    }
+  }
-  public static class authenticateUser_result implements TBase<authenticateUser_result._Fields>, java.io.Serializable, Cloneable   {
+  public static class authenticateUser_result implements TBase<authenticateUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<authenticateUser_result>   {
     private static final TStruct STRUCT_DESC = new TStruct("authenticateUser_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
     private static final TField AUEX_FIELD_DESC = new TField("auex", TType.STRUCT, (short)1);
     @Override
     public int hashCode() {
       return 0;
+    }
+    public int compareTo(authenticateUser_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      authenticateUser_result typedOther = (authenticateUser_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetAuex()).compareTo(isSetAuex());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(auex, typedOther.auex);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
   public static class addAddressForUser_args implements TBase<addAddressForUser_args._Fields>, java.io.Serializable, Cloneable, Comparable<addAddressForUser_args>   {
     private static final TStruct STRUCT_DESC = new TStruct("addAddressForUser_args");
     private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
     private static final TField ADDRESS_FIELD_DESC = new TField("address", TType.STRUCT, (short)2);
-    private static final TField TIMESTAMP_FIELD_DESC = new TField("timestamp", TType.I64, (short)3);
-    private static final TField SET_DEFAULT_FIELD_DESC = new TField("setDefault", TType.BOOL, (short)4);
+    private static final TField SET_DEFAULT_FIELD_DESC = new TField("setDefault", TType.BOOL, (short)3);
     private long userId;
     private Address address;
-    private long timestamp;
     private boolean setDefault;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
       USER_ID((short)1, "userId"),
       ADDRESS((short)2, "address"),
-      TIMESTAMP((short)3, "timestamp"),
-      SET_DEFAULT((short)4, "setDefault");
+      SET_DEFAULT((short)3, "setDefault");
       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
+      }
+    }
     // isset id assignments
     private static final int __USERID_ISSET_ID = 0;
-    private static final int __TIMESTAMP_ISSET_ID = 1;
-    private static final int __SETDEFAULT_ISSET_ID = 2;
+    private static final int __SETDEFAULT_ISSET_ID = 1;
-    private BitSet __isset_bit_vector = new BitSet(3);
+    private BitSet __isset_bit_vector = new BitSet(2);
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
       put(_Fields.ADDRESS, new FieldMetaData("address", TFieldRequirementType.DEFAULT,
           new StructMetaData(TType.STRUCT, Address.class)));
-      put(_Fields.TIMESTAMP, new FieldMetaData("timestamp", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.I64)));
       put(_Fields.SET_DEFAULT, new FieldMetaData("setDefault", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.BOOL)));
     }});
     static {
+    }
     public addAddressForUser_args(
       long userId,
       Address address,
-      long timestamp,
       boolean setDefault)
+    {
       this();
       this.userId = userId;
       setUserIdIsSet(true);
       this.address = address;
-      this.timestamp = timestamp;
-      setTimestampIsSet(true);
       this.setDefault = setDefault;
       setSetDefaultIsSet(true);
+    }
     /**
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.userId = other.userId;
       if (other.isSetAddress()) {
         this.address = new Address(other.address);
+      }
-      this.timestamp = other.timestamp;
       this.setDefault = other.setDefault;
+    }
     public addAddressForUser_args deepCopy() {
       return new addAddressForUser_args(this);
       if (!value) {
         this.address = null;
+      }
+    }
-    public long getTimestamp() {
-      return this.timestamp;
-    }
-    public addAddressForUser_args setTimestamp(long timestamp) {
-      this.timestamp = timestamp;
-      setTimestampIsSet(true);
-      return this;
-    }
-    public void unsetTimestamp() {
-      __isset_bit_vector.clear(__TIMESTAMP_ISSET_ID);
-    }
-    /** Returns true if field timestamp is set (has been asigned a value) and false otherwise */
-    public boolean isSetTimestamp() {
-      return __isset_bit_vector.get(__TIMESTAMP_ISSET_ID);
-    }
-    public void setTimestampIsSet(boolean value) {
-      __isset_bit_vector.set(__TIMESTAMP_ISSET_ID, value);
-    }
     public boolean isSetDefault() {
       return this.setDefault;
+    }
     public addAddressForUser_args setSetDefault(boolean setDefault) {
         } else {
           setAddress((Address)value);
+        }
         break;
-      case TIMESTAMP:
-        if (value == null) {
-          unsetTimestamp();
-        } else {
-          setTimestamp((Long)value);
-        }
-        break;
       case SET_DEFAULT:
         if (value == null) {
           unsetSetDefault();
         } else {
           setSetDefault((Boolean)value);
         return new Long(getUserId());
       case ADDRESS:
         return getAddress();
-      case TIMESTAMP:
-        return new Long(getTimestamp());
       case SET_DEFAULT:
         return new Boolean(isSetDefault());
+      }
       throw new IllegalStateException();
       switch (field) {
       case USER_ID:
         return isSetUserId();
       case ADDRESS:
         return isSetAddress();
-      case TIMESTAMP:
-        return isSetTimestamp();
       case SET_DEFAULT:
         return isSetSetDefault();
+      }
       throw new IllegalStateException();
+    }
           return false;
         if (!this.address.equals(that.address))
           return false;
+      }
-      boolean this_present_timestamp = true;
-      boolean that_present_timestamp = true;
-      if (this_present_timestamp || that_present_timestamp) {
-        if (!(this_present_timestamp && that_present_timestamp))
-          return false;
-        if (this.timestamp != that.timestamp)
-          return false;
-      }
       boolean this_present_setDefault = true;
       boolean that_present_setDefault = true;
       if (this_present_setDefault || that_present_setDefault) {
         if (!(this_present_setDefault && that_present_setDefault))
           return false;
+      }
       lastComparison = TBaseHelper.compareTo(address, typedOther.address);
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(isSetTimestamp());
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-      lastComparison = TBaseHelper.compareTo(timestamp, typedOther.timestamp);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
       lastComparison = Boolean.valueOf(isSetSetDefault()).compareTo(isSetSetDefault());
       if (lastComparison != 0) {
         return lastComparison;
+      }
       lastComparison = TBaseHelper.compareTo(setDefault, typedOther.setDefault);
                 this.address.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case TIMESTAMP:
-              if (field.type == TType.I64) {
-                this.timestamp = iprot.readI64();
-                setTimestampIsSet(true);
-              } else {
-                TProtocolUtil.skip(iprot, field.type);
-              }
-              break;
             case SET_DEFAULT:
               if (field.type == TType.BOOL) {
                 this.setDefault = iprot.readBool();
                 setSetDefaultIsSet(true);
               } else {
       if (this.address != null) {
         oprot.writeFieldBegin(ADDRESS_FIELD_DESC);
         this.address.write(oprot);
         oprot.writeFieldEnd();
+      }
-      oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
-      oprot.writeI64(this.timestamp);
-      oprot.writeFieldEnd();
       oprot.writeFieldBegin(SET_DEFAULT_FIELD_DESC);
       oprot.writeBool(this.setDefault);
       oprot.writeFieldEnd();
       oprot.writeFieldStop();
       oprot.writeStructEnd();
       } else {
         sb.append(this.address);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("timestamp:");
-      sb.append(this.timestamp);
-      first = false;
-      if (!first) sb.append(", ");
       sb.append("setDefault:");
       sb.append(this.setDefault);
       first = false;
       sb.append(")");
       return sb.toString();
+  }
   public static class addAddressForUser_result implements TBase<addAddressForUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<addAddressForUser_result>   {
     private static final TStruct STRUCT_DESC = new TStruct("addAddressForUser_result");
-    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
     private static final TField UCX_FIELD_DESC = new TField("ucx", TType.STRUCT, (short)1);
-    private boolean success;
+    private long success;
     private UserContextException ucx;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
       SUCCESS((short)0, "success"),
     private static final int __SUCCESS_ISSET_ID = 0;
     private BitSet __isset_bit_vector = new BitSet(1);
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.BOOL)));
+          new FieldValueMetaData(TType.I64)));
       put(_Fields.UCX, new FieldMetaData("ucx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
     public addAddressForUser_result() {
+    }
     public addAddressForUser_result(
-      boolean success,
+      long success,
       UserContextException ucx)
+    {
       this();
       this.success = success;
       setSuccessIsSet(true);
     @Deprecated
     public addAddressForUser_result clone() {
       return new addAddressForUser_result(this);
+    }
-    public boolean isSuccess() {
+    public long getSuccess() {
       return this.success;
+    }
-    public addAddressForUser_result setSuccess(boolean success) {
+    public addAddressForUser_result setSuccess(long success) {
       this.success = success;
       setSuccessIsSet(true);
       return this;
+    }
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((Boolean)value);
+          setSuccess((Long)value);
+        }
         break;
       case UCX:
         if (value == null) {
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
-        return new Boolean(isSuccess());
+        return new Long(getSuccess());
       case UCX:
         return getUcx();
+      }
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
             case SUCCESS:
-              if (field.type == TType.BOOL) {
+              if (field.type == TType.I64) {
-                this.success = iprot.readBool();
+                this.success = iprot.readI64();
                 setSuccessIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
     public void write(TProtocol oprot) throws TException {
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-        oprot.writeBool(this.success);
+        oprot.writeI64(this.success);
         oprot.writeFieldEnd();
       } else if (this.isSetUcx()) {
         oprot.writeFieldBegin(UCX_FIELD_DESC);
         this.ucx.write(oprot);
         oprot.writeFieldEnd();
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list25 = iprot.readListBegin();
+                  TList _list21 = iprot.readListBegin();
-                  this.success = new ArrayList<Cart>(_list25.size);
+                  this.success = new ArrayList<Cart>(_list21.size);
-                  for (int _i26 = 0; _i26 < _list25.size; ++_i26)
+                  for (int _i22 = 0; _i22 < _list21.size; ++_i22)
+                  {
-                    Cart _elem27;
+                    Cart _elem23;
-                    _elem27 = new Cart();
+                    _elem23 = new Cart();
-                    _elem27.read(iprot);
+                    _elem23.read(iprot);
-                    this.success.add(_elem27);
+                    this.success.add(_elem23);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Cart _iter28 : this.success)
+          for (Cart _iter24 : this.success)
+          {
-            _iter28.write(oprot);
+            _iter24.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetScx()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list29 = iprot.readListBegin();
+                  TList _list25 = iprot.readListBegin();
-                  this.success = new ArrayList<Cart>(_list29.size);
+                  this.success = new ArrayList<Cart>(_list25.size);
-                  for (int _i30 = 0; _i30 < _list29.size; ++_i30)
+                  for (int _i26 = 0; _i26 < _list25.size; ++_i26)
+                  {
-                    Cart _elem31;
+                    Cart _elem27;
-                    _elem31 = new Cart();
+                    _elem27 = new Cart();
-                    _elem31.read(iprot);
+                    _elem27.read(iprot);
-                    this.success.add(_elem31);
+                    this.success.add(_elem27);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Cart _iter32 : this.success)
+          for (Cart _iter28 : this.success)
+          {
-            _iter32.write(oprot);
+            _iter28.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetScx()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list33 = iprot.readListBegin();
+                  TList _list29 = iprot.readListBegin();
-                  this.success = new ArrayList<Cart>(_list33.size);
+                  this.success = new ArrayList<Cart>(_list29.size);
-                  for (int _i34 = 0; _i34 < _list33.size; ++_i34)
+                  for (int _i30 = 0; _i30 < _list29.size; ++_i30)
+                  {
-                    Cart _elem35;
+                    Cart _elem31;
-                    _elem35 = new Cart();
+                    _elem31 = new Cart();
-                    _elem35.read(iprot);
+                    _elem31.read(iprot);
-                    this.success.add(_elem35);
+                    this.success.add(_elem31);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Cart _iter36 : this.success)
+          for (Cart _iter32 : this.success)
+          {
-            _iter36.write(oprot);
+            _iter32.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetScx()) {
+              }
               break;
             case ITEMS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list37 = iprot.readListBegin();
+                  TList _list33 = iprot.readListBegin();
-                  this.items = new ArrayList<Long>(_list37.size);
+                  this.items = new ArrayList<Long>(_list33.size);
-                  for (int _i38 = 0; _i38 < _list37.size; ++_i38)
+                  for (int _i34 = 0; _i34 < _list33.size; ++_i34)
+                  {
-                    long _elem39;
+                    long _elem35;
-                    _elem39 = iprot.readI64();
+                    _elem35 = iprot.readI64();
-                    this.items.add(_elem39);
+                    this.items.add(_elem35);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.items != null) {
         oprot.writeFieldBegin(ITEMS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.I64, this.items.size()));
-          for (long _iter40 : this.items)
+          for (long _iter36 : this.items)
+          {
-            oprot.writeI64(_iter40);
+            oprot.writeI64(_iter36);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/in/shop2020/model/v1/user/UserContextService.java @ 571 – Rev 553 → 571