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

     public void changeItemStatus(long cartId, long itemId, LineStatus status) throws ShoppingCartException, TException;
     public void addAddressToCart(long cartId, long addressId) throws ShoppingCartException, TException;
+    /**
+     * Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
+     *
+     * @param cartId
+     */
-    public long commitCart(long cartId) throws ShoppingCartException, TException;
+    public long createOrders(long cartId) throws ShoppingCartException, TException;
+    /**
+     * Validates that:
+     * 1. The checkout timestamp is greater than the updatedOn timestamp.
+     * 2. None of the lines in the cart for an inactive item.
+     * 3. The estimate for any of the lines in cart doesn't change.
+     * Returns true only if all three hold.
+     *
+     * @param cartId
+     */
     public boolean validateCart(long cartId) throws ShoppingCartException, TException;
+    /**
-    public boolean refreshCart(long cartId) throws ShoppingCartException, TException;
+     * Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
+     *
+     * @param fromCartId
+     * @param toCartId
+     */
     public void mergeCart(long fromCartId, long toCartId) throws TException;
+    /**
+     * Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
+     *
+     * @param cartId
+     */
+    public boolean checkOut(long cartId) throws ShoppingCartException, TException;
+    /**
+     * The second parameter is a map of item ids and their quantities which have been successfully processed.
+     * This methods removes the specified quantiry of the specified item from the cart.
+     *
+     * @param cartId
+     * @param items
+     */
+    public boolean resetCart(long cartId, Map<Long,Long> items) throws ShoppingCartException, TException;
     public void addWidget(Widget widget) throws WidgetException, TException;
     public void addItemToWidget(long widget_id, List<Long> items) throws WidgetException, TException;
     public void deleteItemFromWidget(long widget_id, long item_id) throws WidgetException, TException;
         throw result.scx;
+      }
       return;
+    }
-    public long commitCart(long cartId) throws ShoppingCartException, TException
+    public long createOrders(long cartId) throws ShoppingCartException, TException
+    {
-      send_commitCart(cartId);
+      send_createOrders(cartId);
-      return recv_commitCart();
+      return recv_createOrders();
+    }
-    public void send_commitCart(long cartId) throws TException
+    public void send_createOrders(long cartId) throws TException
+    {
-      oprot_.writeMessageBegin(new TMessage("commitCart", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("createOrders", TMessageType.CALL, seqid_));
-      commitCart_args args = new commitCart_args();
+      createOrders_args args = new createOrders_args();
       args.cartId = cartId;
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
-    public long recv_commitCart() throws ShoppingCartException, TException
+    public long recv_createOrders() throws ShoppingCartException, TException
+    {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
         TApplicationException x = TApplicationException.read(iprot_);
         iprot_.readMessageEnd();
         throw x;
+      }
-      commitCart_result result = new commitCart_result();
+      createOrders_result result = new createOrders_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
       if (result.isSetSuccess()) {
         return result.success;
+      }
       if (result.scx != null) {
         throw result.scx;
+      }
-      throw new TApplicationException(TApplicationException.MISSING_RESULT, "commitCart failed: unknown result");
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
+    }
     public boolean validateCart(long cartId) throws ShoppingCartException, TException
+    {
       send_validateCart(cartId);
         throw result.scex;
+      }
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
+    }
-    public boolean refreshCart(long cartId) throws ShoppingCartException, TException
+    public void mergeCart(long fromCartId, long toCartId) throws TException
+    {
+      send_mergeCart(fromCartId, toCartId);
+      recv_mergeCart();
+    }
+    public void send_mergeCart(long fromCartId, long toCartId) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("mergeCart", TMessageType.CALL, seqid_));
+      mergeCart_args args = new mergeCart_args();
+      args.fromCartId = fromCartId;
+      args.toCartId = toCartId;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public void recv_mergeCart() throws TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      mergeCart_result result = new mergeCart_result();
-      send_refreshCart(cartId);
+      result.read(iprot_);
-      return recv_refreshCart();
+      iprot_.readMessageEnd();
+      return;
+    }
-    public void send_refreshCart(long cartId) throws TException
+    public boolean checkOut(long cartId) throws ShoppingCartException, TException
+    {
+      send_checkOut(cartId);
+      return recv_checkOut();
+    }
+    public void send_checkOut(long cartId) throws TException
+    {
-      oprot_.writeMessageBegin(new TMessage("refreshCart", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("checkOut", TMessageType.CALL, seqid_));
-      refreshCart_args args = new refreshCart_args();
+      checkOut_args args = new checkOut_args();
       args.cartId = cartId;
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
-    public boolean recv_refreshCart() throws ShoppingCartException, TException
+    public boolean recv_checkOut() throws ShoppingCartException, TException
+    {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
         TApplicationException x = TApplicationException.read(iprot_);
         iprot_.readMessageEnd();
         throw x;
+      }
-      refreshCart_result result = new refreshCart_result();
+      checkOut_result result = new checkOut_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
       if (result.isSetSuccess()) {
         return result.success;
+      }
       if (result.scex != null) {
         throw result.scex;
+      }
-      throw new TApplicationException(TApplicationException.MISSING_RESULT, "refreshCart failed: unknown result");
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
+    }
-    public void mergeCart(long fromCartId, long toCartId) throws TException
+    public boolean resetCart(long cartId, Map<Long,Long> items) throws ShoppingCartException, TException
+    {
-      send_mergeCart(fromCartId, toCartId);
+      send_resetCart(cartId, items);
-      recv_mergeCart();
+      return recv_resetCart();
+    }
-    public void send_mergeCart(long fromCartId, long toCartId) throws TException
+    public void send_resetCart(long cartId, Map<Long,Long> items) throws TException
+    {
-      oprot_.writeMessageBegin(new TMessage("mergeCart", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("resetCart", TMessageType.CALL, seqid_));
-      mergeCart_args args = new mergeCart_args();
+      resetCart_args args = new resetCart_args();
-      args.fromCartId = fromCartId;
+      args.cartId = cartId;
-      args.toCartId = toCartId;
+      args.items = items;
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
-    public void recv_mergeCart() throws TException
+    public boolean recv_resetCart() throws ShoppingCartException, TException
+    {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
         TApplicationException x = TApplicationException.read(iprot_);
         iprot_.readMessageEnd();
         throw x;
+      }
-      mergeCart_result result = new mergeCart_result();
+      resetCart_result result = new resetCart_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
-      return;
+      }
+      if (result.scex != null) {
+        throw result.scex;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
+    }
     public void addWidget(Widget widget) throws WidgetException, TException
+    {
       send_addWidget(widget);
       processMap_.put("addItemToCart", new addItemToCart());
       processMap_.put("deleteItemFromCart", new deleteItemFromCart());
       processMap_.put("changeQuantity", new changeQuantity());
       processMap_.put("changeItemStatus", new changeItemStatus());
       processMap_.put("addAddressToCart", new addAddressToCart());
-      processMap_.put("commitCart", new commitCart());
+      processMap_.put("createOrders", new createOrders());
       processMap_.put("validateCart", new validateCart());
-      processMap_.put("refreshCart", new refreshCart());
       processMap_.put("mergeCart", new mergeCart());
+      processMap_.put("checkOut", new checkOut());
+      processMap_.put("resetCart", new resetCart());
       processMap_.put("addWidget", new addWidget());
       processMap_.put("addItemToWidget", new addItemToWidget());
       processMap_.put("deleteItemFromWidget", new deleteItemFromWidget());
       processMap_.put("updateWidget", new updateWidget());
       processMap_.put("updateWidgetItem", new updateWidgetItem());
         oprot.getTransport().flush();
+      }
+    }
-    private class commitCart implements ProcessFunction {
+    private class createOrders implements ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
-        commitCart_args args = new commitCart_args();
+        createOrders_args args = new createOrders_args();
         args.read(iprot);
         iprot.readMessageEnd();
-        commitCart_result result = new commitCart_result();
+        createOrders_result result = new createOrders_result();
         try {
-          result.success = iface_.commitCart(args.cartId);
+          result.success = iface_.createOrders(args.cartId);
           result.setSuccessIsSet(true);
         } catch (ShoppingCartException scx) {
           result.scx = scx;
         } catch (Throwable th) {
-          LOGGER.error("Internal error processing commitCart", th);
+          LOGGER.error("Internal error processing createOrders", th);
-          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing commitCart");
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createOrders");
-          oprot.writeMessageBegin(new TMessage("commitCart", TMessageType.EXCEPTION, seqid));
+          oprot.writeMessageBegin(new TMessage("createOrders", TMessageType.EXCEPTION, seqid));
           x.write(oprot);
           oprot.writeMessageEnd();
           oprot.getTransport().flush();
           return;
+        }
-        oprot.writeMessageBegin(new TMessage("commitCart", TMessageType.REPLY, seqid));
+        oprot.writeMessageBegin(new TMessage("createOrders", TMessageType.REPLY, seqid));
         result.write(oprot);
         oprot.writeMessageEnd();
         oprot.getTransport().flush();
+      }
         oprot.getTransport().flush();
+      }
+    }
-    private class refreshCart implements ProcessFunction {
+    private class mergeCart implements ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
-        refreshCart_args args = new refreshCart_args();
+        mergeCart_args args = new mergeCart_args();
         args.read(iprot);
         iprot.readMessageEnd();
-        refreshCart_result result = new refreshCart_result();
+        mergeCart_result result = new mergeCart_result();
+        iface_.mergeCart(args.fromCartId, args.toCartId);
+        oprot.writeMessageBegin(new TMessage("mergeCart", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class checkOut implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        checkOut_args args = new checkOut_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        checkOut_result result = new checkOut_result();
         try {
-          result.success = iface_.refreshCart(args.cartId);
+          result.success = iface_.checkOut(args.cartId);
           result.setSuccessIsSet(true);
         } catch (ShoppingCartException scex) {
           result.scex = scex;
         } catch (Throwable th) {
-          LOGGER.error("Internal error processing refreshCart", th);
+          LOGGER.error("Internal error processing checkOut", th);
-          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing refreshCart");
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing checkOut");
-          oprot.writeMessageBegin(new TMessage("refreshCart", TMessageType.EXCEPTION, seqid));
+          oprot.writeMessageBegin(new TMessage("checkOut", TMessageType.EXCEPTION, seqid));
           x.write(oprot);
           oprot.writeMessageEnd();
           oprot.getTransport().flush();
           return;
+        }
-        oprot.writeMessageBegin(new TMessage("refreshCart", TMessageType.REPLY, seqid));
+        oprot.writeMessageBegin(new TMessage("checkOut", TMessageType.REPLY, seqid));
         result.write(oprot);
         oprot.writeMessageEnd();
         oprot.getTransport().flush();
+      }
+    }
-    private class mergeCart implements ProcessFunction {
+    private class resetCart implements ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
-        mergeCart_args args = new mergeCart_args();
+        resetCart_args args = new resetCart_args();
         args.read(iprot);
         iprot.readMessageEnd();
-        mergeCart_result result = new mergeCart_result();
+        resetCart_result result = new resetCart_result();
+        try {
-        iface_.mergeCart(args.fromCartId, args.toCartId);
+          result.success = iface_.resetCart(args.cartId, args.items);
+          result.setSuccessIsSet(true);
+        } catch (ShoppingCartException scex) {
+          result.scex = scex;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing resetCart", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing resetCart");
+          oprot.writeMessageBegin(new TMessage("resetCart", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
-        oprot.writeMessageBegin(new TMessage("mergeCart", TMessageType.REPLY, seqid));
+        oprot.writeMessageBegin(new TMessage("resetCart", TMessageType.REPLY, seqid));
         result.write(oprot);
         oprot.writeMessageEnd();
         oprot.getTransport().flush();
+      }
       // check for required fields
+    }
+  }
-  public static class commitCart_args implements TBase<commitCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<commitCart_args>   {
+  public static class createOrders_args implements TBase<createOrders_args._Fields>, java.io.Serializable, Cloneable, Comparable<createOrders_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("commitCart_args");
+    private static final TStruct STRUCT_DESC = new TStruct("createOrders_args");
     private static final TField CART_ID_FIELD_DESC = new TField("cartId", TType.I64, (short)1);
     private long cartId;
       put(_Fields.CART_ID, new FieldMetaData("cartId", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(commitCart_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(createOrders_args.class, metaDataMap);
+    }
-    public commitCart_args() {
+    public createOrders_args() {
+    }
-    public commitCart_args(
+    public createOrders_args(
       long cartId)
+    {
       this();
       this.cartId = cartId;
       setCartIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public commitCart_args(commitCart_args other) {
+    public createOrders_args(createOrders_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.cartId = other.cartId;
+    }
-    public commitCart_args deepCopy() {
+    public createOrders_args deepCopy() {
-      return new commitCart_args(this);
+      return new createOrders_args(this);
+    }
     @Deprecated
-    public commitCart_args clone() {
+    public createOrders_args clone() {
-      return new commitCart_args(this);
+      return new createOrders_args(this);
+    }
     public long getCartId() {
       return this.cartId;
+    }
-    public commitCart_args setCartId(long cartId) {
+    public createOrders_args setCartId(long cartId) {
       this.cartId = cartId;
       setCartIdIsSet(true);
       return this;
+    }
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof commitCart_args)
+      if (that instanceof createOrders_args)
-        return this.equals((commitCart_args)that);
+        return this.equals((createOrders_args)that);
       return false;
+    }
-    public boolean equals(commitCart_args that) {
+    public boolean equals(createOrders_args that) {
       if (that == null)
         return false;
       boolean this_present_cartId = true;
       boolean that_present_cartId = true;
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(commitCart_args other) {
+    public int compareTo(createOrders_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      commitCart_args typedOther = (commitCart_args)other;
+      createOrders_args typedOther = (createOrders_args)other;
       lastComparison = Boolean.valueOf(isSetCartId()).compareTo(isSetCartId());
       if (lastComparison != 0) {
         return lastComparison;
+      }
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("commitCart_args(");
+      StringBuilder sb = new StringBuilder("createOrders_args(");
       boolean first = true;
       sb.append("cartId:");
       sb.append(this.cartId);
       first = false;
       // check for required fields
+    }
+  }
-  public static class commitCart_result implements TBase<commitCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<commitCart_result>   {
+  public static class createOrders_result implements TBase<createOrders_result._Fields>, java.io.Serializable, Cloneable, Comparable<createOrders_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("commitCart_result");
+    private static final TStruct STRUCT_DESC = new TStruct("createOrders_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
     private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
     private long success;
       put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(commitCart_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(createOrders_result.class, metaDataMap);
+    }
-    public commitCart_result() {
+    public createOrders_result() {
+    }
-    public commitCart_result(
+    public createOrders_result(
       long success,
       ShoppingCartException scx)
+    {
       this();
       this.success = success;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public commitCart_result(commitCart_result other) {
+    public createOrders_result(createOrders_result other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.success = other.success;
       if (other.isSetScx()) {
         this.scx = new ShoppingCartException(other.scx);
+      }
+    }
-    public commitCart_result deepCopy() {
+    public createOrders_result deepCopy() {
-      return new commitCart_result(this);
+      return new createOrders_result(this);
+    }
     @Deprecated
-    public commitCart_result clone() {
+    public createOrders_result clone() {
-      return new commitCart_result(this);
+      return new createOrders_result(this);
+    }
     public long getSuccess() {
       return this.success;
+    }
-    public commitCart_result setSuccess(long success) {
+    public createOrders_result setSuccess(long success) {
       this.success = success;
       setSuccessIsSet(true);
       return this;
+    }
     public ShoppingCartException getScx() {
       return this.scx;
+    }
-    public commitCart_result setScx(ShoppingCartException scx) {
+    public createOrders_result setScx(ShoppingCartException scx) {
       this.scx = scx;
       return this;
+    }
     public void unsetScx() {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof commitCart_result)
+      if (that instanceof createOrders_result)
-        return this.equals((commitCart_result)that);
+        return this.equals((createOrders_result)that);
       return false;
+    }
-    public boolean equals(commitCart_result that) {
+    public boolean equals(createOrders_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true;
       boolean that_present_success = true;
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(commitCart_result other) {
+    public int compareTo(createOrders_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      commitCart_result typedOther = (commitCart_result)other;
+      createOrders_result typedOther = (createOrders_result)other;
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
+      }
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("commitCart_result(");
+      StringBuilder sb = new StringBuilder("createOrders_result(");
       boolean first = true;
       sb.append("success:");
       sb.append(this.success);
       first = false;
       // check for required fields
+    }
+  }
-  public static class refreshCart_args implements TBase<refreshCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<refreshCart_args>   {
+  public static class mergeCart_args implements TBase<mergeCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<mergeCart_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("refreshCart_args");
+    private static final TStruct STRUCT_DESC = new TStruct("mergeCart_args");
+    private static final TField FROM_CART_ID_FIELD_DESC = new TField("fromCartId", TType.I64, (short)1);
+    private static final TField TO_CART_ID_FIELD_DESC = new TField("toCartId", TType.I64, (short)2);
+    private long fromCartId;
+    private long toCartId;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      FROM_CART_ID((short)1, "fromCartId"),
+      TO_CART_ID((short)2, "toCartId");
+      private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byId.put((int)field._thriftId, field);
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        return byId.get(fieldId);
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __FROMCARTID_ISSET_ID = 0;
+    private static final int __TOCARTID_ISSET_ID = 1;
+    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.FROM_CART_ID, new FieldMetaData("fromCartId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.TO_CART_ID, new FieldMetaData("toCartId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(mergeCart_args.class, metaDataMap);
+    }
+    public mergeCart_args() {
+    }
+    public mergeCart_args(
+      long fromCartId,
+      long toCartId)
+    {
+      this();
+      this.fromCartId = fromCartId;
+      setFromCartIdIsSet(true);
+      this.toCartId = toCartId;
+      setToCartIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public mergeCart_args(mergeCart_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.fromCartId = other.fromCartId;
+      this.toCartId = other.toCartId;
+    }
+    public mergeCart_args deepCopy() {
+      return new mergeCart_args(this);
+    }
+    @Deprecated
+    public mergeCart_args clone() {
+      return new mergeCart_args(this);
+    }
+    public long getFromCartId() {
+      return this.fromCartId;
+    }
+    public mergeCart_args setFromCartId(long fromCartId) {
+      this.fromCartId = fromCartId;
+      setFromCartIdIsSet(true);
+      return this;
+    }
+    public void unsetFromCartId() {
+      __isset_bit_vector.clear(__FROMCARTID_ISSET_ID);
+    }
+    /** Returns true if field fromCartId is set (has been asigned a value) and false otherwise */
+    public boolean isSetFromCartId() {
+      return __isset_bit_vector.get(__FROMCARTID_ISSET_ID);
+    }
+    public void setFromCartIdIsSet(boolean value) {
+      __isset_bit_vector.set(__FROMCARTID_ISSET_ID, value);
+    }
+    public long getToCartId() {
+      return this.toCartId;
+    }
+    public mergeCart_args setToCartId(long toCartId) {
+      this.toCartId = toCartId;
+      setToCartIdIsSet(true);
+      return this;
+    }
+    public void unsetToCartId() {
+      __isset_bit_vector.clear(__TOCARTID_ISSET_ID);
+    }
+    /** Returns true if field toCartId is set (has been asigned a value) and false otherwise */
+    public boolean isSetToCartId() {
+      return __isset_bit_vector.get(__TOCARTID_ISSET_ID);
+    }
+    public void setToCartIdIsSet(boolean value) {
+      __isset_bit_vector.set(__TOCARTID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case FROM_CART_ID:
+        if (value == null) {
+          unsetFromCartId();
+        } else {
+          setFromCartId((Long)value);
+        }
+        break;
+      case TO_CART_ID:
+        if (value == null) {
+          unsetToCartId();
+        } else {
+          setToCartId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case FROM_CART_ID:
+        return new Long(getFromCartId());
+      case TO_CART_ID:
+        return new Long(getToCartId());
+      }
+      throw new IllegalStateException();
+    }
+    public Object getFieldValue(int fieldId) {
+      return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+    }
+    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      switch (field) {
+      case FROM_CART_ID:
+        return isSetFromCartId();
+      case TO_CART_ID:
+        return isSetToCartId();
+      }
+      throw new IllegalStateException();
+    }
+    public boolean isSet(int fieldID) {
+      return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof mergeCart_args)
+        return this.equals((mergeCart_args)that);
+      return false;
+    }
+    public boolean equals(mergeCart_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_fromCartId = true;
+      boolean that_present_fromCartId = true;
+      if (this_present_fromCartId || that_present_fromCartId) {
+        if (!(this_present_fromCartId && that_present_fromCartId))
+          return false;
+        if (this.fromCartId != that.fromCartId)
+          return false;
+      }
+      boolean this_present_toCartId = true;
+      boolean that_present_toCartId = true;
+      if (this_present_toCartId || that_present_toCartId) {
+        if (!(this_present_toCartId && that_present_toCartId))
+          return false;
+        if (this.toCartId != that.toCartId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(mergeCart_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      mergeCart_args typedOther = (mergeCart_args)other;
+      lastComparison = Boolean.valueOf(isSetFromCartId()).compareTo(isSetFromCartId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(fromCartId, typedOther.fromCartId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetToCartId()).compareTo(isSetToCartId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(toCartId, typedOther.toCartId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
+    public void read(TProtocol iprot) throws TException {
+      TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == TType.STOP) {
+          break;
+        }
+        _Fields fieldId = _Fields.findByThriftId(field.id);
+        if (fieldId == null) {
+          TProtocolUtil.skip(iprot, field.type);
+        } else {
+          switch (fieldId) {
+            case FROM_CART_ID:
+              if (field.type == TType.I64) {
+                this.fromCartId = iprot.readI64();
+                setFromCartIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case TO_CART_ID:
+              if (field.type == TType.I64) {
+                this.toCartId = iprot.readI64();
+                setToCartIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(FROM_CART_ID_FIELD_DESC);
+      oprot.writeI64(this.fromCartId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(TO_CART_ID_FIELD_DESC);
+      oprot.writeI64(this.toCartId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("mergeCart_args(");
+      boolean first = true;
+      sb.append("fromCartId:");
+      sb.append(this.fromCartId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("toCartId:");
+      sb.append(this.toCartId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class mergeCart_result implements TBase<mergeCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<mergeCart_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("mergeCart_result");
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+;
+      private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byId.put((int)field._thriftId, field);
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        return byId.get(fieldId);
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(mergeCart_result.class, metaDataMap);
+    }
+    public mergeCart_result() {
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public mergeCart_result(mergeCart_result other) {
+    }
+    public mergeCart_result deepCopy() {
+      return new mergeCart_result(this);
+    }
+    @Deprecated
+    public mergeCart_result clone() {
+      return new mergeCart_result(this);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      }
+      throw new IllegalStateException();
+    }
+    public Object getFieldValue(int fieldId) {
+      return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+    }
+    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      switch (field) {
+      }
+      throw new IllegalStateException();
+    }
+    public boolean isSet(int fieldID) {
+      return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof mergeCart_result)
+        return this.equals((mergeCart_result)that);
+      return false;
+    }
+    public boolean equals(mergeCart_result that) {
+      if (that == null)
+        return false;
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(mergeCart_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      mergeCart_result typedOther = (mergeCart_result)other;
+      return 0;
+    }
+    public void read(TProtocol iprot) throws TException {
+      TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == TType.STOP) {
+          break;
+        }
+        _Fields fieldId = _Fields.findByThriftId(field.id);
+        if (fieldId == null) {
+          TProtocolUtil.skip(iprot, field.type);
+        } else {
+          switch (fieldId) {
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("mergeCart_result(");
+      boolean first = true;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class checkOut_args implements TBase<checkOut_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkOut_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("checkOut_args");
     private static final TField CART_ID_FIELD_DESC = new TField("cartId", TType.I64, (short)1);
     private long cartId;
       put(_Fields.CART_ID, new FieldMetaData("cartId", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(refreshCart_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(checkOut_args.class, metaDataMap);
+    }
-    public refreshCart_args() {
+    public checkOut_args() {
+    }
-    public refreshCart_args(
+    public checkOut_args(
       long cartId)
+    {
       this();
       this.cartId = cartId;
       setCartIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public refreshCart_args(refreshCart_args other) {
+    public checkOut_args(checkOut_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.cartId = other.cartId;
+    }
-    public refreshCart_args deepCopy() {
+    public checkOut_args deepCopy() {
-      return new refreshCart_args(this);
+      return new checkOut_args(this);
+    }
     @Deprecated
-    public refreshCart_args clone() {
+    public checkOut_args clone() {
-      return new refreshCart_args(this);
+      return new checkOut_args(this);
+    }
     public long getCartId() {
       return this.cartId;
+    }
-    public refreshCart_args setCartId(long cartId) {
+    public checkOut_args setCartId(long cartId) {
       this.cartId = cartId;
       setCartIdIsSet(true);
       return this;
+    }
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof refreshCart_args)
+      if (that instanceof checkOut_args)
-        return this.equals((refreshCart_args)that);
+        return this.equals((checkOut_args)that);
       return false;
+    }
-    public boolean equals(refreshCart_args that) {
+    public boolean equals(checkOut_args that) {
       if (that == null)
         return false;
       boolean this_present_cartId = true;
       boolean that_present_cartId = true;
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(refreshCart_args other) {
+    public int compareTo(checkOut_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      refreshCart_args typedOther = (refreshCart_args)other;
+      checkOut_args typedOther = (checkOut_args)other;
       lastComparison = Boolean.valueOf(isSetCartId()).compareTo(isSetCartId());
       if (lastComparison != 0) {
         return lastComparison;
+      }
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("refreshCart_args(");
+      StringBuilder sb = new StringBuilder("checkOut_args(");
       boolean first = true;
       sb.append("cartId:");
       sb.append(this.cartId);
       first = false;
       // check for required fields
+    }
+  }
-  public static class refreshCart_result implements TBase<refreshCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<refreshCart_result>   {
+  public static class checkOut_result implements TBase<checkOut_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkOut_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("refreshCart_result");
+    private static final TStruct STRUCT_DESC = new TStruct("checkOut_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
     private static final TField SCEX_FIELD_DESC = new TField("scex", TType.STRUCT, (short)1);
     private boolean success;
       put(_Fields.SCEX, new FieldMetaData("scex", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(refreshCart_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(checkOut_result.class, metaDataMap);
+    }
-    public refreshCart_result() {
+    public checkOut_result() {
+    }
-    public refreshCart_result(
+    public checkOut_result(
       boolean success,
       ShoppingCartException scex)
+    {
       this();
       this.success = success;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public refreshCart_result(refreshCart_result other) {
+    public checkOut_result(checkOut_result other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.success = other.success;
       if (other.isSetScex()) {
         this.scex = new ShoppingCartException(other.scex);
+      }
+    }
-    public refreshCart_result deepCopy() {
+    public checkOut_result deepCopy() {
-      return new refreshCart_result(this);
+      return new checkOut_result(this);
+    }
     @Deprecated
-    public refreshCart_result clone() {
+    public checkOut_result clone() {
-      return new refreshCart_result(this);
+      return new checkOut_result(this);
+    }
     public boolean isSuccess() {
       return this.success;
+    }
-    public refreshCart_result setSuccess(boolean success) {
+    public checkOut_result setSuccess(boolean success) {
       this.success = success;
       setSuccessIsSet(true);
       return this;
+    }
     public ShoppingCartException getScex() {
       return this.scex;
+    }
-    public refreshCart_result setScex(ShoppingCartException scex) {
+    public checkOut_result setScex(ShoppingCartException scex) {
       this.scex = scex;
       return this;
+    }
     public void unsetScex() {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof refreshCart_result)
+      if (that instanceof checkOut_result)
-        return this.equals((refreshCart_result)that);
+        return this.equals((checkOut_result)that);
       return false;
+    }
-    public boolean equals(refreshCart_result that) {
+    public boolean equals(checkOut_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true;
       boolean that_present_success = true;
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(refreshCart_result other) {
+    public int compareTo(checkOut_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      refreshCart_result typedOther = (refreshCart_result)other;
+      checkOut_result typedOther = (checkOut_result)other;
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
+      }
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("refreshCart_result(");
+      StringBuilder sb = new StringBuilder("checkOut_result(");
       boolean first = true;
       sb.append("success:");
       sb.append(this.success);
       first = false;
       // check for required fields
+    }
+  }
-  public static class mergeCart_args implements TBase<mergeCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<mergeCart_args>   {
+  public static class resetCart_args implements TBase<resetCart_args._Fields>, java.io.Serializable, Cloneable   {
-    private static final TStruct STRUCT_DESC = new TStruct("mergeCart_args");
+    private static final TStruct STRUCT_DESC = new TStruct("resetCart_args");
-    private static final TField FROM_CART_ID_FIELD_DESC = new TField("fromCartId", TType.I64, (short)1);
+    private static final TField CART_ID_FIELD_DESC = new TField("cartId", TType.I64, (short)1);
-    private static final TField TO_CART_ID_FIELD_DESC = new TField("toCartId", TType.I64, (short)2);
+    private static final TField ITEMS_FIELD_DESC = new TField("items", TType.MAP, (short)2);
-    private long fromCartId;
+    private long cartId;
-    private long toCartId;
+    private Map<Long,Long> items;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
-      FROM_CART_ID((short)1, "fromCartId"),
+      CART_ID((short)1, "cartId"),
-      TO_CART_ID((short)2, "toCartId");
+      ITEMS((short)2, "items");
       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
         return _fieldName;
+      }
+    }
     // isset id assignments
-    private static final int __FROMCARTID_ISSET_ID = 0;
-    private static final int __TOCARTID_ISSET_ID = 1;
+    private static final int __CARTID_ISSET_ID = 0;
-    private BitSet __isset_bit_vector = new BitSet(2);
+    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.FROM_CART_ID, new FieldMetaData("fromCartId", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.I64)));
-      put(_Fields.TO_CART_ID, new FieldMetaData("toCartId", TFieldRequirementType.DEFAULT,
+      put(_Fields.CART_ID, new FieldMetaData("cartId", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
+      put(_Fields.ITEMS, new FieldMetaData("items", TFieldRequirementType.DEFAULT,
+          new MapMetaData(TType.MAP,
+              new FieldValueMetaData(TType.I64),
+              new FieldValueMetaData(TType.I64))));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(mergeCart_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(resetCart_args.class, metaDataMap);
+    }
-    public mergeCart_args() {
+    public resetCart_args() {
+    }
-    public mergeCart_args(
+    public resetCart_args(
-      long fromCartId,
+      long cartId,
-      long toCartId)
+      Map<Long,Long> items)
+    {
       this();
-      this.fromCartId = fromCartId;
+      this.cartId = cartId;
-      setFromCartIdIsSet(true);
+      setCartIdIsSet(true);
-      this.toCartId = toCartId;
+      this.items = items;
-      setToCartIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public mergeCart_args(mergeCart_args other) {
+    public resetCart_args(resetCart_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
-      this.fromCartId = other.fromCartId;
+      this.cartId = other.cartId;
+      if (other.isSetItems()) {
+        Map<Long,Long> __this__items = new HashMap<Long,Long>();
+        for (Map.Entry<Long, Long> other_element : other.items.entrySet()) {
+          Long other_element_key = other_element.getKey();
+          Long other_element_value = other_element.getValue();
+          Long __this__items_copy_key = other_element_key;
+          Long __this__items_copy_value = other_element_value;
+          __this__items.put(__this__items_copy_key, __this__items_copy_value);
+        }
-      this.toCartId = other.toCartId;
+        this.items = __this__items;
+      }
+    }
-    public mergeCart_args deepCopy() {
+    public resetCart_args deepCopy() {
-      return new mergeCart_args(this);
+      return new resetCart_args(this);
+    }
     @Deprecated
-    public mergeCart_args clone() {
+    public resetCart_args clone() {
-      return new mergeCart_args(this);
+      return new resetCart_args(this);
+    }
-    public long getFromCartId() {
+    public long getCartId() {
-      return this.fromCartId;
+      return this.cartId;
+    }
-    public mergeCart_args setFromCartId(long fromCartId) {
+    public resetCart_args setCartId(long cartId) {
-      this.fromCartId = fromCartId;
+      this.cartId = cartId;
-      setFromCartIdIsSet(true);
+      setCartIdIsSet(true);
       return this;
+    }
-    public void unsetFromCartId() {
+    public void unsetCartId() {
-      __isset_bit_vector.clear(__FROMCARTID_ISSET_ID);
+      __isset_bit_vector.clear(__CARTID_ISSET_ID);
+    }
-    /** Returns true if field fromCartId is set (has been asigned a value) and false otherwise */
+    /** Returns true if field cartId is set (has been asigned a value) and false otherwise */
-    public boolean isSetFromCartId() {
+    public boolean isSetCartId() {
-      return __isset_bit_vector.get(__FROMCARTID_ISSET_ID);
+      return __isset_bit_vector.get(__CARTID_ISSET_ID);
+    }
-    public void setFromCartIdIsSet(boolean value) {
+    public void setCartIdIsSet(boolean value) {
-      __isset_bit_vector.set(__FROMCARTID_ISSET_ID, value);
+      __isset_bit_vector.set(__CARTID_ISSET_ID, value);
+    }
-    public long getToCartId() {
+    public int getItemsSize() {
-      return this.toCartId;
+      return (this.items == null) ? 0 : this.items.size();
+    }
-    public mergeCart_args setToCartId(long toCartId) {
+    public void putToItems(long key, long val) {
+      if (this.items == null) {
+        this.items = new HashMap<Long,Long>();
+      }
-      this.toCartId = toCartId;
+      this.items.put(key, val);
+    }
+    public Map<Long,Long> getItems() {
-      setToCartIdIsSet(true);
+      return this.items;
+    }
+    public resetCart_args setItems(Map<Long,Long> items) {
+      this.items = items;
       return this;
+    }
-    public void unsetToCartId() {
+    public void unsetItems() {
-      __isset_bit_vector.clear(__TOCARTID_ISSET_ID);
+      this.items = null;
+    }
-    /** Returns true if field toCartId is set (has been asigned a value) and false otherwise */
+    /** Returns true if field items is set (has been asigned a value) and false otherwise */
-    public boolean isSetToCartId() {
+    public boolean isSetItems() {
-      return __isset_bit_vector.get(__TOCARTID_ISSET_ID);
+      return this.items != null;
+    }
-    public void setToCartIdIsSet(boolean value) {
+    public void setItemsIsSet(boolean value) {
+      if (!value) {
-      __isset_bit_vector.set(__TOCARTID_ISSET_ID, value);
+        this.items = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case FROM_CART_ID:
+      case CART_ID:
         if (value == null) {
-          unsetFromCartId();
+          unsetCartId();
         } else {
-          setFromCartId((Long)value);
+          setCartId((Long)value);
+        }
         break;
-      case TO_CART_ID:
+      case ITEMS:
         if (value == null) {
-          unsetToCartId();
+          unsetItems();
         } else {
-          setToCartId((Long)value);
+          setItems((Map<Long,Long>)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case FROM_CART_ID:
+      case CART_ID:
-        return new Long(getFromCartId());
+        return new Long(getCartId());
-      case TO_CART_ID:
+      case ITEMS:
-        return new Long(getToCartId());
+        return getItems();
+      }
       throw new IllegalStateException();
+    }
+    }
     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
     public boolean isSet(_Fields field) {
       switch (field) {
-      case FROM_CART_ID:
+      case CART_ID:
-        return isSetFromCartId();
+        return isSetCartId();
-      case TO_CART_ID:
+      case ITEMS:
-        return isSetToCartId();
+        return isSetItems();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof mergeCart_args)
+      if (that instanceof resetCart_args)
-        return this.equals((mergeCart_args)that);
+        return this.equals((resetCart_args)that);
       return false;
+    }
-    public boolean equals(mergeCart_args that) {
+    public boolean equals(resetCart_args that) {
       if (that == null)
         return false;
-      boolean this_present_fromCartId = true;
+      boolean this_present_cartId = true;
-      boolean that_present_fromCartId = true;
+      boolean that_present_cartId = true;
-      if (this_present_fromCartId || that_present_fromCartId) {
+      if (this_present_cartId || that_present_cartId) {
-        if (!(this_present_fromCartId && that_present_fromCartId))
+        if (!(this_present_cartId && that_present_cartId))
           return false;
-        if (this.fromCartId != that.fromCartId)
+        if (this.cartId != that.cartId)
           return false;
+      }
-      boolean this_present_toCartId = true;
+      boolean this_present_items = true && this.isSetItems();
-      boolean that_present_toCartId = true;
+      boolean that_present_items = true && that.isSetItems();
-      if (this_present_toCartId || that_present_toCartId) {
+      if (this_present_items || that_present_items) {
-        if (!(this_present_toCartId && that_present_toCartId))
+        if (!(this_present_items && that_present_items))
           return false;
-        if (this.toCartId != that.toCartId)
+        if (!this.items.equals(that.items))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(mergeCart_args other) {
-      if (!getClass().equals(other.getClass())) {
-        return getClass().getName().compareTo(other.getClass().getName());
-      }
-      int lastComparison = 0;
-      mergeCart_args typedOther = (mergeCart_args)other;
-      lastComparison = Boolean.valueOf(isSetFromCartId()).compareTo(isSetFromCartId());
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-      lastComparison = TBaseHelper.compareTo(fromCartId, typedOther.fromCartId);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-      lastComparison = Boolean.valueOf(isSetToCartId()).compareTo(isSetToCartId());
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-      lastComparison = TBaseHelper.compareTo(toCartId, typedOther.toCartId);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-      return 0;
-    }
     public void read(TProtocol iprot) throws TException {
       TField field;
       iprot.readStructBegin();
       while (true)
+      {
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case FROM_CART_ID:
+            case CART_ID:
               if (field.type == TType.I64) {
-                this.fromCartId = iprot.readI64();
+                this.cartId = iprot.readI64();
-                setFromCartIdIsSet(true);
+                setCartIdIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case TO_CART_ID:
+            case ITEMS:
-              if (field.type == TType.I64) {
+              if (field.type == TType.MAP) {
+                {
+                  TMap _map37 = iprot.readMapBegin();
+                  this.items = new HashMap<Long,Long>(2*_map37.size);
+                  for (int _i38 = 0; _i38 < _map37.size; ++_i38)
+                  {
+                    long _key39;
+                    long _val40;
+                    _key39 = iprot.readI64();
-                this.toCartId = iprot.readI64();
+                    _val40 = iprot.readI64();
+                    this.items.put(_key39, _val40);
+                  }
-                setToCartIdIsSet(true);
+                  iprot.readMapEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
-      oprot.writeFieldBegin(FROM_CART_ID_FIELD_DESC);
-      oprot.writeI64(this.fromCartId);
-      oprot.writeFieldEnd();
-      oprot.writeFieldBegin(TO_CART_ID_FIELD_DESC);
+      oprot.writeFieldBegin(CART_ID_FIELD_DESC);
-      oprot.writeI64(this.toCartId);
+      oprot.writeI64(this.cartId);
       oprot.writeFieldEnd();
+      if (this.items != null) {
+        oprot.writeFieldBegin(ITEMS_FIELD_DESC);
+        {
+          oprot.writeMapBegin(new TMap(TType.I64, TType.I64, this.items.size()));
+          for (Map.Entry<Long, Long> _iter41 : this.items.entrySet())
+          {
+            oprot.writeI64(_iter41.getKey());
+            oprot.writeI64(_iter41.getValue());
+          }
+          oprot.writeMapEnd();
+        }
+        oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("mergeCart_args(");
+      StringBuilder sb = new StringBuilder("resetCart_args(");
       boolean first = true;
-      sb.append("fromCartId:");
+      sb.append("cartId:");
-      sb.append(this.fromCartId);
+      sb.append(this.cartId);
       first = false;
       if (!first) sb.append(", ");
-      sb.append("toCartId:");
+      sb.append("items:");
+      if (this.items == null) {
+        sb.append("null");
+      } else {
-      sb.append(this.toCartId);
+        sb.append(this.items);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class mergeCart_result implements TBase<mergeCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<mergeCart_result>   {
+  public static class resetCart_result implements TBase<resetCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<resetCart_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("mergeCart_result");
+    private static final TStruct STRUCT_DESC = new TStruct("resetCart_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
+    private static final TField SCEX_FIELD_DESC = new TField("scex", TType.STRUCT, (short)1);
+    private boolean success;
+    private ShoppingCartException scex;
     /** 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"),
+      SCEX((short)1, "scex");
       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
       public String getFieldName() {
         return _fieldName;
+      }
+    }
+    // isset id assignments
+    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)));
+      put(_Fields.SCEX, new FieldMetaData("scex", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(mergeCart_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(resetCart_result.class, metaDataMap);
+    }
-    public mergeCart_result() {
+    public resetCart_result() {
+    }
+    public resetCart_result(
+      boolean success,
+      ShoppingCartException scex)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+      this.scex = scex;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public mergeCart_result(mergeCart_result other) {
+    public resetCart_result(resetCart_result other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.success = other.success;
+      if (other.isSetScex()) {
+        this.scex = new ShoppingCartException(other.scex);
+      }
+    }
-    public mergeCart_result deepCopy() {
+    public resetCart_result deepCopy() {
-      return new mergeCart_result(this);
+      return new resetCart_result(this);
+    }
     @Deprecated
-    public mergeCart_result clone() {
+    public resetCart_result clone() {
-      return new mergeCart_result(this);
+      return new resetCart_result(this);
+    }
+    public boolean isSuccess() {
+      return this.success;
+    }
+    public resetCart_result setSuccess(boolean success) {
+      this.success = success;
+      setSuccessIsSet(true);
+      return this;
+    }
+    public void unsetSuccess() {
+      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
+    }
+    public void setSuccessIsSet(boolean value) {
+      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
+    }
+    public ShoppingCartException getScex() {
+      return this.scex;
+    }
+    public resetCart_result setScex(ShoppingCartException scex) {
+      this.scex = scex;
+      return this;
+    }
+    public void unsetScex() {
+      this.scex = null;
+    }
+    /** Returns true if field scex is set (has been asigned a value) and false otherwise */
+    public boolean isSetScex() {
+      return this.scex != null;
+    }
+    public void setScexIsSet(boolean value) {
+      if (!value) {
+        this.scex = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Boolean)value);
+        }
+        break;
+      case SCEX:
+        if (value == null) {
+          unsetScex();
+        } else {
+          setScex((ShoppingCartException)value);
+        }
+        break;
+      }
+    }
     public void setFieldValue(int fieldID, Object value) {
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
+      case SUCCESS:
+        return new Boolean(isSuccess());
+      case SCEX:
+        return getScex();
+      }
       throw new IllegalStateException();
+    }
     public Object getFieldValue(int fieldId) {
+    }
     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
     public boolean isSet(_Fields field) {
       switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      case SCEX:
+        return isSetScex();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof mergeCart_result)
+      if (that instanceof resetCart_result)
-        return this.equals((mergeCart_result)that);
+        return this.equals((resetCart_result)that);
       return false;
+    }
-    public boolean equals(mergeCart_result that) {
+    public boolean equals(resetCart_result that) {
       if (that == null)
         return false;
+      boolean this_present_success = true;
+      boolean that_present_success = true;
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (this.success != that.success)
+          return false;
+      }
+      boolean this_present_scex = true && this.isSetScex();
+      boolean that_present_scex = true && that.isSetScex();
+      if (this_present_scex || that_present_scex) {
+        if (!(this_present_scex && that_present_scex))
+          return false;
+        if (!this.scex.equals(that.scex))
+          return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(mergeCart_result other) {
+    public int compareTo(resetCart_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      mergeCart_result typedOther = (mergeCart_result)other;
+      resetCart_result typedOther = (resetCart_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(isSetScex()).compareTo(isSetScex());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(scex, typedOther.scex);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
       return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
+            case SUCCESS:
+              if (field.type == TType.BOOL) {
+                this.success = iprot.readBool();
+                setSuccessIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case SCEX:
+              if (field.type == TType.STRUCT) {
+                this.scex = new ShoppingCartException();
+                this.scex.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
           iprot.readFieldEnd();
+        }
+      }
       iprot.readStructEnd();
+    }
     public void write(TProtocol oprot) throws TException {
       oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        oprot.writeBool(this.success);
+        oprot.writeFieldEnd();
+      } else if (this.isSetScex()) {
+        oprot.writeFieldBegin(SCEX_FIELD_DESC);
+        this.scex.write(oprot);
+        oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("mergeCart_result(");
+      StringBuilder sb = new StringBuilder("resetCart_result(");
       boolean first = true;
+      sb.append("success:");
+      sb.append(this.success);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("scex:");
+      if (this.scex == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.scex);
+      }
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws TException {
+              }
               break;
             case ITEMS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list37 = iprot.readListBegin();
+                  TList _list42 = iprot.readListBegin();
-                  this.items = new ArrayList<Long>(_list37.size);
+                  this.items = new ArrayList<Long>(_list42.size);
-                  for (int _i38 = 0; _i38 < _list37.size; ++_i38)
+                  for (int _i43 = 0; _i43 < _list42.size; ++_i43)
+                  {
-                    long _elem39;
+                    long _elem44;
-                    _elem39 = iprot.readI64();
+                    _elem44 = iprot.readI64();
-                    this.items.add(_elem39);
+                    this.items.add(_elem44);
+                  }
                   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 _iter45 : this.items)
+          {
-            oprot.writeI64(_iter40);
+            oprot.writeI64(_iter45);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

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