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

     public List<UserCommunication> getUserCommunicationByUser(long userId) throws UserCommunicationException, TException;
     public List<UserCommunication> getAllUserCommunications() throws UserCommunicationException, TException;
+    public MasterAffiliate createMasterAffiliate(String name) throws UserTrackerException, TException;
+    public MasterAffiliate getMasterAffiliateById(long id) throws UserTrackerException, TException;
+    public MasterAffiliate getMasterAffiliateByName(String name) throws UserTrackerException, TException;
+    public Affiliate createAffiliate(String name, String url, long masterAffiliateId) throws UserTrackerException, TException;
+    public Affiliate getAffiliateById(long id) throws UserTrackerException, TException;
+    public Affiliate getAffiliateByName(String name) throws UserTrackerException, TException;
+    public List<Affiliate> getAffiliatesByMasterAffiliate(long id) throws UserTrackerException, TException;
+    public Tracker createTracker(long affiliateId) throws UserTrackerException, TException;
+    public Tracker getTrackerById(long trackerId) throws UserTrackerException, TException;
+    public List<Tracker> getTrackersByAffiliate(long affiliateId) throws UserTrackerException, TException;
+    public long addTrackLog(long trackerId, long userId, String event, String url, String data) throws UserTrackerException, TException;
+    public TrackLog getTrackLogById(long id) throws UserTrackerException, TException;
+    public List<TrackLog> getTrackLogsByTracker(long trackerId) throws UserTrackerException, TException;
+    public List<TrackLog> getTrackLogsByUser(long userId) throws UserTrackerException, TException;
+    public List<TrackLog> getTrackLogs(long trackerId, long userId, String event, String url) throws UserTrackerException, TException;
     public long createCart(long userId) throws ShoppingCartException, TException;
     public Cart getCurrentCart(long userId) throws ShoppingCartException, TException;
     public Cart getCart(long cartId) throws ShoppingCartException, TException;
         throw result.ucx;
+      }
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
+    }
+    public MasterAffiliate createMasterAffiliate(String name) throws UserTrackerException, TException
+    {
+      send_createMasterAffiliate(name);
+      return recv_createMasterAffiliate();
+    }
+    public void send_createMasterAffiliate(String name) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("createMasterAffiliate", TMessageType.CALL, seqid_));
+      createMasterAffiliate_args args = new createMasterAffiliate_args();
+      args.name = name;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public MasterAffiliate recv_createMasterAffiliate() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      createMasterAffiliate_result result = new createMasterAffiliate_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
+    }
+    public MasterAffiliate getMasterAffiliateById(long id) throws UserTrackerException, TException
+    {
+      send_getMasterAffiliateById(id);
+      return recv_getMasterAffiliateById();
+    }
+    public void send_getMasterAffiliateById(long id) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getMasterAffiliateById", TMessageType.CALL, seqid_));
+      getMasterAffiliateById_args args = new getMasterAffiliateById_args();
+      args.id = id;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public MasterAffiliate recv_getMasterAffiliateById() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getMasterAffiliateById_result result = new getMasterAffiliateById_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
+    }
+    public MasterAffiliate getMasterAffiliateByName(String name) throws UserTrackerException, TException
+    {
+      send_getMasterAffiliateByName(name);
+      return recv_getMasterAffiliateByName();
+    }
+    public void send_getMasterAffiliateByName(String name) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getMasterAffiliateByName", TMessageType.CALL, seqid_));
+      getMasterAffiliateByName_args args = new getMasterAffiliateByName_args();
+      args.name = name;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public MasterAffiliate recv_getMasterAffiliateByName() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getMasterAffiliateByName_result result = new getMasterAffiliateByName_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
+    }
+    public Affiliate createAffiliate(String name, String url, long masterAffiliateId) throws UserTrackerException, TException
+    {
+      send_createAffiliate(name, url, masterAffiliateId);
+      return recv_createAffiliate();
+    }
+    public void send_createAffiliate(String name, String url, long masterAffiliateId) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("createAffiliate", TMessageType.CALL, seqid_));
+      createAffiliate_args args = new createAffiliate_args();
+      args.name = name;
+      args.url = url;
+      args.masterAffiliateId = masterAffiliateId;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public Affiliate recv_createAffiliate() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      createAffiliate_result result = new createAffiliate_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
+    }
+    public Affiliate getAffiliateById(long id) throws UserTrackerException, TException
+    {
+      send_getAffiliateById(id);
+      return recv_getAffiliateById();
+    }
+    public void send_getAffiliateById(long id) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getAffiliateById", TMessageType.CALL, seqid_));
+      getAffiliateById_args args = new getAffiliateById_args();
+      args.id = id;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public Affiliate recv_getAffiliateById() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getAffiliateById_result result = new getAffiliateById_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
+    }
+    public Affiliate getAffiliateByName(String name) throws UserTrackerException, TException
+    {
+      send_getAffiliateByName(name);
+      return recv_getAffiliateByName();
+    }
+    public void send_getAffiliateByName(String name) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getAffiliateByName", TMessageType.CALL, seqid_));
+      getAffiliateByName_args args = new getAffiliateByName_args();
+      args.name = name;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public Affiliate recv_getAffiliateByName() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getAffiliateByName_result result = new getAffiliateByName_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
+    }
+    public List<Affiliate> getAffiliatesByMasterAffiliate(long id) throws UserTrackerException, TException
+    {
+      send_getAffiliatesByMasterAffiliate(id);
+      return recv_getAffiliatesByMasterAffiliate();
+    }
+    public void send_getAffiliatesByMasterAffiliate(long id) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getAffiliatesByMasterAffiliate", TMessageType.CALL, seqid_));
+      getAffiliatesByMasterAffiliate_args args = new getAffiliatesByMasterAffiliate_args();
+      args.id = id;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public List<Affiliate> recv_getAffiliatesByMasterAffiliate() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getAffiliatesByMasterAffiliate_result result = new getAffiliatesByMasterAffiliate_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
+    }
+    public Tracker createTracker(long affiliateId) throws UserTrackerException, TException
+    {
+      send_createTracker(affiliateId);
+      return recv_createTracker();
+    }
+    public void send_createTracker(long affiliateId) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("createTracker", TMessageType.CALL, seqid_));
+      createTracker_args args = new createTracker_args();
+      args.affiliateId = affiliateId;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public Tracker recv_createTracker() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      createTracker_result result = new createTracker_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createTracker failed: unknown result");
+    }
+    public Tracker getTrackerById(long trackerId) throws UserTrackerException, TException
+    {
+      send_getTrackerById(trackerId);
+      return recv_getTrackerById();
+    }
+    public void send_getTrackerById(long trackerId) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getTrackerById", TMessageType.CALL, seqid_));
+      getTrackerById_args args = new getTrackerById_args();
+      args.trackerId = trackerId;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public Tracker recv_getTrackerById() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getTrackerById_result result = new getTrackerById_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
+    }
+    public List<Tracker> getTrackersByAffiliate(long affiliateId) throws UserTrackerException, TException
+    {
+      send_getTrackersByAffiliate(affiliateId);
+      return recv_getTrackersByAffiliate();
+    }
+    public void send_getTrackersByAffiliate(long affiliateId) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getTrackersByAffiliate", TMessageType.CALL, seqid_));
+      getTrackersByAffiliate_args args = new getTrackersByAffiliate_args();
+      args.affiliateId = affiliateId;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public List<Tracker> recv_getTrackersByAffiliate() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getTrackersByAffiliate_result result = new getTrackersByAffiliate_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTrackersByAffiliate failed: unknown result");
+    }
+    public long addTrackLog(long trackerId, long userId, String event, String url, String data) throws UserTrackerException, TException
+    {
+      send_addTrackLog(trackerId, userId, event, url, data);
+      return recv_addTrackLog();
+    }
+    public void send_addTrackLog(long trackerId, long userId, String event, String url, String data) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("addTrackLog", TMessageType.CALL, seqid_));
+      addTrackLog_args args = new addTrackLog_args();
+      args.trackerId = trackerId;
+      args.userId = userId;
+      args.event = event;
+      args.url = url;
+      args.data = data;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public long recv_addTrackLog() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      addTrackLog_result result = new addTrackLog_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
+    }
+    public TrackLog getTrackLogById(long id) throws UserTrackerException, TException
+    {
+      send_getTrackLogById(id);
+      return recv_getTrackLogById();
+    }
+    public void send_getTrackLogById(long id) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getTrackLogById", TMessageType.CALL, seqid_));
+      getTrackLogById_args args = new getTrackLogById_args();
+      args.id = id;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public TrackLog recv_getTrackLogById() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getTrackLogById_result result = new getTrackLogById_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
+    }
+    public List<TrackLog> getTrackLogsByTracker(long trackerId) throws UserTrackerException, TException
+    {
+      send_getTrackLogsByTracker(trackerId);
+      return recv_getTrackLogsByTracker();
+    }
+    public void send_getTrackLogsByTracker(long trackerId) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getTrackLogsByTracker", TMessageType.CALL, seqid_));
+      getTrackLogsByTracker_args args = new getTrackLogsByTracker_args();
+      args.trackerId = trackerId;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public List<TrackLog> recv_getTrackLogsByTracker() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getTrackLogsByTracker_result result = new getTrackLogsByTracker_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByTracker failed: unknown result");
+    }
+    public List<TrackLog> getTrackLogsByUser(long userId) throws UserTrackerException, TException
+    {
+      send_getTrackLogsByUser(userId);
+      return recv_getTrackLogsByUser();
+    }
+    public void send_getTrackLogsByUser(long userId) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getTrackLogsByUser", TMessageType.CALL, seqid_));
+      getTrackLogsByUser_args args = new getTrackLogsByUser_args();
+      args.userId = userId;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public List<TrackLog> recv_getTrackLogsByUser() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getTrackLogsByUser_result result = new getTrackLogsByUser_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
+    }
+    public List<TrackLog> getTrackLogs(long trackerId, long userId, String event, String url) throws UserTrackerException, TException
+    {
+      send_getTrackLogs(trackerId, userId, event, url);
+      return recv_getTrackLogs();
+    }
+    public void send_getTrackLogs(long trackerId, long userId, String event, String url) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("getTrackLogs", TMessageType.CALL, seqid_));
+      getTrackLogs_args args = new getTrackLogs_args();
+      args.trackerId = trackerId;
+      args.userId = userId;
+      args.event = event;
+      args.url = url;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public List<TrackLog> recv_getTrackLogs() throws UserTrackerException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      getTrackLogs_result result = new getTrackLogs_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.utx != null) {
+        throw result.utx;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
+    }
     public long createCart(long userId) throws ShoppingCartException, TException
+    {
       send_createCart(userId);
       return recv_createCart();
+    }
       processMap_.put("getDefaultPincode", new getDefaultPincode());
       processMap_.put("saveUserCommunication", new saveUserCommunication());
       processMap_.put("getUserCommunicationById", new getUserCommunicationById());
       processMap_.put("getUserCommunicationByUser", new getUserCommunicationByUser());
       processMap_.put("getAllUserCommunications", new getAllUserCommunications());
+      processMap_.put("createMasterAffiliate", new createMasterAffiliate());
+      processMap_.put("getMasterAffiliateById", new getMasterAffiliateById());
+      processMap_.put("getMasterAffiliateByName", new getMasterAffiliateByName());
+      processMap_.put("createAffiliate", new createAffiliate());
+      processMap_.put("getAffiliateById", new getAffiliateById());
+      processMap_.put("getAffiliateByName", new getAffiliateByName());
+      processMap_.put("getAffiliatesByMasterAffiliate", new getAffiliatesByMasterAffiliate());
+      processMap_.put("createTracker", new createTracker());
+      processMap_.put("getTrackerById", new getTrackerById());
+      processMap_.put("getTrackersByAffiliate", new getTrackersByAffiliate());
+      processMap_.put("addTrackLog", new addTrackLog());
+      processMap_.put("getTrackLogById", new getTrackLogById());
+      processMap_.put("getTrackLogsByTracker", new getTrackLogsByTracker());
+      processMap_.put("getTrackLogsByUser", new getTrackLogsByUser());
+      processMap_.put("getTrackLogs", new getTrackLogs());
       processMap_.put("createCart", new createCart());
       processMap_.put("getCurrentCart", new getCurrentCart());
       processMap_.put("getCart", new getCart());
       processMap_.put("getCartsForUser", new getCartsForUser());
       processMap_.put("getCartsByStatus", new getCartsByStatus());
         oprot.getTransport().flush();
+      }
+    }
+    private class createMasterAffiliate implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        createMasterAffiliate_args args = new createMasterAffiliate_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        createMasterAffiliate_result result = new createMasterAffiliate_result();
+        try {
+          result.success = iface_.createMasterAffiliate(args.name);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing createMasterAffiliate", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createMasterAffiliate");
+          oprot.writeMessageBegin(new TMessage("createMasterAffiliate", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("createMasterAffiliate", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getMasterAffiliateById implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getMasterAffiliateById_args args = new getMasterAffiliateById_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getMasterAffiliateById_result result = new getMasterAffiliateById_result();
+        try {
+          result.success = iface_.getMasterAffiliateById(args.id);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getMasterAffiliateById", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getMasterAffiliateById");
+          oprot.writeMessageBegin(new TMessage("getMasterAffiliateById", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getMasterAffiliateById", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getMasterAffiliateByName implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getMasterAffiliateByName_args args = new getMasterAffiliateByName_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getMasterAffiliateByName_result result = new getMasterAffiliateByName_result();
+        try {
+          result.success = iface_.getMasterAffiliateByName(args.name);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getMasterAffiliateByName", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getMasterAffiliateByName");
+          oprot.writeMessageBegin(new TMessage("getMasterAffiliateByName", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getMasterAffiliateByName", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class createAffiliate implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        createAffiliate_args args = new createAffiliate_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        createAffiliate_result result = new createAffiliate_result();
+        try {
+          result.success = iface_.createAffiliate(args.name, args.url, args.masterAffiliateId);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing createAffiliate", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createAffiliate");
+          oprot.writeMessageBegin(new TMessage("createAffiliate", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("createAffiliate", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getAffiliateById implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getAffiliateById_args args = new getAffiliateById_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getAffiliateById_result result = new getAffiliateById_result();
+        try {
+          result.success = iface_.getAffiliateById(args.id);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getAffiliateById", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getAffiliateById");
+          oprot.writeMessageBegin(new TMessage("getAffiliateById", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getAffiliateById", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getAffiliateByName implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getAffiliateByName_args args = new getAffiliateByName_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getAffiliateByName_result result = new getAffiliateByName_result();
+        try {
+          result.success = iface_.getAffiliateByName(args.name);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getAffiliateByName", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getAffiliateByName");
+          oprot.writeMessageBegin(new TMessage("getAffiliateByName", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getAffiliateByName", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getAffiliatesByMasterAffiliate implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getAffiliatesByMasterAffiliate_args args = new getAffiliatesByMasterAffiliate_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getAffiliatesByMasterAffiliate_result result = new getAffiliatesByMasterAffiliate_result();
+        try {
+          result.success = iface_.getAffiliatesByMasterAffiliate(args.id);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getAffiliatesByMasterAffiliate", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getAffiliatesByMasterAffiliate");
+          oprot.writeMessageBegin(new TMessage("getAffiliatesByMasterAffiliate", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class createTracker implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        createTracker_args args = new createTracker_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        createTracker_result result = new createTracker_result();
+        try {
+          result.success = iface_.createTracker(args.affiliateId);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing createTracker", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing createTracker");
+          oprot.writeMessageBegin(new TMessage("createTracker", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("createTracker", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getTrackerById implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getTrackerById_args args = new getTrackerById_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getTrackerById_result result = new getTrackerById_result();
+        try {
+          result.success = iface_.getTrackerById(args.trackerId);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getTrackerById", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTrackerById");
+          oprot.writeMessageBegin(new TMessage("getTrackerById", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getTrackerById", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getTrackersByAffiliate implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getTrackersByAffiliate_args args = new getTrackersByAffiliate_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getTrackersByAffiliate_result result = new getTrackersByAffiliate_result();
+        try {
+          result.success = iface_.getTrackersByAffiliate(args.affiliateId);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getTrackersByAffiliate", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTrackersByAffiliate");
+          oprot.writeMessageBegin(new TMessage("getTrackersByAffiliate", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getTrackersByAffiliate", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class addTrackLog implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        addTrackLog_args args = new addTrackLog_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        addTrackLog_result result = new addTrackLog_result();
+        try {
+          result.success = iface_.addTrackLog(args.trackerId, args.userId, args.event, args.url, args.data);
+          result.setSuccessIsSet(true);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing addTrackLog", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing addTrackLog");
+          oprot.writeMessageBegin(new TMessage("addTrackLog", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("addTrackLog", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getTrackLogById implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getTrackLogById_args args = new getTrackLogById_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getTrackLogById_result result = new getTrackLogById_result();
+        try {
+          result.success = iface_.getTrackLogById(args.id);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getTrackLogById", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTrackLogById");
+          oprot.writeMessageBegin(new TMessage("getTrackLogById", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getTrackLogById", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getTrackLogsByTracker implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getTrackLogsByTracker_args args = new getTrackLogsByTracker_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getTrackLogsByTracker_result result = new getTrackLogsByTracker_result();
+        try {
+          result.success = iface_.getTrackLogsByTracker(args.trackerId);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getTrackLogsByTracker", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTrackLogsByTracker");
+          oprot.writeMessageBegin(new TMessage("getTrackLogsByTracker", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getTrackLogsByTracker", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getTrackLogsByUser implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getTrackLogsByUser_args args = new getTrackLogsByUser_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getTrackLogsByUser_result result = new getTrackLogsByUser_result();
+        try {
+          result.success = iface_.getTrackLogsByUser(args.userId);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getTrackLogsByUser", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTrackLogsByUser");
+          oprot.writeMessageBegin(new TMessage("getTrackLogsByUser", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getTrackLogsByUser", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getTrackLogs implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getTrackLogs_args args = new getTrackLogs_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getTrackLogs_result result = new getTrackLogs_result();
+        try {
+          result.success = iface_.getTrackLogs(args.trackerId, args.userId, args.event, args.url);
+        } catch (UserTrackerException utx) {
+          result.utx = utx;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing getTrackLogs", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getTrackLogs");
+          oprot.writeMessageBegin(new TMessage("getTrackLogs", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("getTrackLogs", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
     private class createCart implements ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
         createCart_args args = new createCart_args();
         args.read(iprot);
       // check for required fields
+    }
+  }
-  public static class createCart_args implements TBase<createCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<createCart_args>   {
+  public static class createMasterAffiliate_args implements TBase<createMasterAffiliate_args._Fields>, java.io.Serializable, Cloneable, Comparable<createMasterAffiliate_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("createCart_args");
+    private static final TStruct STRUCT_DESC = new TStruct("createMasterAffiliate_args");
-    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
+    private static final TField NAME_FIELD_DESC = new TField("name", TType.STRING, (short)1);
-    private long userId;
+    private String name;
     /** 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");
+      NAME((short)1, "name");
       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 __USERID_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.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+      put(_Fields.NAME, new FieldMetaData("name", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.I64)));
+          new FieldValueMetaData(TType.STRING)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(createCart_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(createMasterAffiliate_args.class, metaDataMap);
+    }
-    public createCart_args() {
+    public createMasterAffiliate_args() {
+    }
-    public createCart_args(
+    public createMasterAffiliate_args(
-      long userId)
+      String name)
+    {
       this();
-      this.userId = userId;
+      this.name = name;
-      setUserIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public createCart_args(createCart_args other) {
+    public createMasterAffiliate_args(createMasterAffiliate_args other) {
-      __isset_bit_vector.clear();
+      if (other.isSetName()) {
-      __isset_bit_vector.or(other.__isset_bit_vector);
-      this.userId = other.userId;
+        this.name = other.name;
+      }
+    }
-    public createCart_args deepCopy() {
+    public createMasterAffiliate_args deepCopy() {
-      return new createCart_args(this);
+      return new createMasterAffiliate_args(this);
+    }
     @Deprecated
-    public createCart_args clone() {
+    public createMasterAffiliate_args clone() {
-      return new createCart_args(this);
+      return new createMasterAffiliate_args(this);
+    }
-    public long getUserId() {
+    public String getName() {
-      return this.userId;
+      return this.name;
+    }
-    public createCart_args setUserId(long userId) {
+    public createMasterAffiliate_args setName(String name) {
-      this.userId = userId;
+      this.name = name;
-      setUserIdIsSet(true);
       return this;
+    }
-    public void unsetUserId() {
+    public void unsetName() {
-      __isset_bit_vector.clear(__USERID_ISSET_ID);
+      this.name = null;
+    }
-    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    /** Returns true if field name is set (has been asigned a value) and false otherwise */
-    public boolean isSetUserId() {
+    public boolean isSetName() {
-      return __isset_bit_vector.get(__USERID_ISSET_ID);
+      return this.name != null;
+    }
-    public void setUserIdIsSet(boolean value) {
+    public void setNameIsSet(boolean value) {
+      if (!value) {
-      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+        this.name = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case USER_ID:
+      case NAME:
         if (value == null) {
-          unsetUserId();
+          unsetName();
         } else {
-          setUserId((Long)value);
+          setName((String)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case USER_ID:
+      case NAME:
-        return new Long(getUserId());
+        return getName();
+      }
       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 USER_ID:
+      case NAME:
-        return isSetUserId();
+        return isSetName();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof createCart_args)
+      if (that instanceof createMasterAffiliate_args)
-        return this.equals((createCart_args)that);
+        return this.equals((createMasterAffiliate_args)that);
       return false;
+    }
-    public boolean equals(createCart_args that) {
+    public boolean equals(createMasterAffiliate_args that) {
       if (that == null)
         return false;
-      boolean this_present_userId = true;
+      boolean this_present_name = true && this.isSetName();
-      boolean that_present_userId = true;
+      boolean that_present_name = true && that.isSetName();
-      if (this_present_userId || that_present_userId) {
+      if (this_present_name || that_present_name) {
-        if (!(this_present_userId && that_present_userId))
+        if (!(this_present_name && that_present_name))
           return false;
-        if (this.userId != that.userId)
+        if (!this.name.equals(that.name))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(createCart_args other) {
+    public int compareTo(createMasterAffiliate_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      createCart_args typedOther = (createCart_args)other;
+      createMasterAffiliate_args typedOther = (createMasterAffiliate_args)other;
-      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      lastComparison = Boolean.valueOf(isSetName()).compareTo(isSetName());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      lastComparison = TBaseHelper.compareTo(name, typedOther.name);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case USER_ID:
+            case NAME:
-              if (field.type == TType.I64) {
+              if (field.type == TType.STRING) {
-                this.userId = iprot.readI64();
+                this.name = iprot.readString();
-                setUserIdIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
+      if (this.name != null) {
-      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
+        oprot.writeFieldBegin(NAME_FIELD_DESC);
-      oprot.writeI64(this.userId);
+        oprot.writeString(this.name);
-      oprot.writeFieldEnd();
+        oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("createCart_args(");
+      StringBuilder sb = new StringBuilder("createMasterAffiliate_args(");
       boolean first = true;
-      sb.append("userId:");
+      sb.append("name:");
+      if (this.name == null) {
+        sb.append("null");
+      } else {
-      sb.append(this.userId);
+        sb.append(this.name);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class createCart_result implements TBase<createCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<createCart_result>   {
+  public static class createMasterAffiliate_result implements TBase<createMasterAffiliate_result._Fields>, java.io.Serializable, Cloneable, Comparable<createMasterAffiliate_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("createCart_result");
+    private static final TStruct STRUCT_DESC = new TStruct("createMasterAffiliate_result");
-    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
-    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
-    private long success;
+    private MasterAffiliate success;
-    private ShoppingCartException scx;
+    private UserTrackerException utx;
     /** 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"),
-      SCX((short)1, "scx");
+      UTX((short)1, "utx");
       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 __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.I64)));
+          new StructMetaData(TType.STRUCT, MasterAffiliate.class)));
-      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(createCart_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(createMasterAffiliate_result.class, metaDataMap);
+    }
-    public createCart_result() {
+    public createMasterAffiliate_result() {
+    }
-    public createCart_result(
+    public createMasterAffiliate_result(
-      long success,
+      MasterAffiliate success,
-      ShoppingCartException scx)
+      UserTrackerException utx)
+    {
       this();
       this.success = success;
-      setSuccessIsSet(true);
-      this.scx = scx;
+      this.utx = utx;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public createCart_result(createCart_result other) {
+    public createMasterAffiliate_result(createMasterAffiliate_result other) {
-      __isset_bit_vector.clear();
+      if (other.isSetSuccess()) {
-      __isset_bit_vector.or(other.__isset_bit_vector);
+        this.success = new MasterAffiliate(other.success);
-      this.success = other.success;
+      }
-      if (other.isSetScx()) {
+      if (other.isSetUtx()) {
-        this.scx = new ShoppingCartException(other.scx);
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
-    public createCart_result deepCopy() {
+    public createMasterAffiliate_result deepCopy() {
-      return new createCart_result(this);
+      return new createMasterAffiliate_result(this);
+    }
     @Deprecated
-    public createCart_result clone() {
+    public createMasterAffiliate_result clone() {
-      return new createCart_result(this);
+      return new createMasterAffiliate_result(this);
+    }
-    public long getSuccess() {
+    public MasterAffiliate getSuccess() {
       return this.success;
+    }
-    public createCart_result setSuccess(long success) {
+    public createMasterAffiliate_result setSuccess(MasterAffiliate success) {
       this.success = success;
-      setSuccessIsSet(true);
       return this;
+    }
     public void unsetSuccess() {
-      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
+      this.success = null;
+    }
     /** 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);
+      return this.success != null;
+    }
     public void setSuccessIsSet(boolean value) {
+      if (!value) {
-      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
+        this.success = null;
+      }
+    }
-    public ShoppingCartException getScx() {
+    public UserTrackerException getUtx() {
-      return this.scx;
+      return this.utx;
+    }
-    public createCart_result setScx(ShoppingCartException scx) {
+    public createMasterAffiliate_result setUtx(UserTrackerException utx) {
-      this.scx = scx;
+      this.utx = utx;
       return this;
+    }
-    public void unsetScx() {
+    public void unsetUtx() {
-      this.scx = null;
+      this.utx = null;
+    }
-    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
-    public boolean isSetScx() {
+    public boolean isSetUtx() {
-      return this.scx != null;
+      return this.utx != null;
+    }
-    public void setScxIsSet(boolean value) {
+    public void setUtxIsSet(boolean value) {
       if (!value) {
-        this.scx = null;
+        this.utx = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((Long)value);
+          setSuccess((MasterAffiliate)value);
+        }
         break;
-      case SCX:
+      case UTX:
         if (value == null) {
-          unsetScx();
+          unsetUtx();
         } else {
-          setScx((ShoppingCartException)value);
+          setUtx((UserTrackerException)value);
+        }
         break;
+      }
+    }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
-        return new Long(getSuccess());
+        return getSuccess();
-      case SCX:
+      case UTX:
-        return getScx();
+        return getUtx();
+      }
       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 SUCCESS:
         return isSetSuccess();
-      case SCX:
+      case UTX:
-        return isSetScx();
+        return isSetUtx();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof createCart_result)
+      if (that instanceof createMasterAffiliate_result)
-        return this.equals((createCart_result)that);
+        return this.equals((createMasterAffiliate_result)that);
       return false;
+    }
-    public boolean equals(createCart_result that) {
+    public boolean equals(createMasterAffiliate_result that) {
       if (that == null)
         return false;
-      boolean this_present_success = true;
+      boolean this_present_success = true && this.isSetSuccess();
-      boolean that_present_success = true;
+      boolean that_present_success = true && that.isSetSuccess();
       if (this_present_success || that_present_success) {
         if (!(this_present_success && that_present_success))
           return false;
-        if (this.success != that.success)
+        if (!this.success.equals(that.success))
           return false;
+      }
-      boolean this_present_scx = true && this.isSetScx();
+      boolean this_present_utx = true && this.isSetUtx();
-      boolean that_present_scx = true && that.isSetScx();
+      boolean that_present_utx = true && that.isSetUtx();
-      if (this_present_scx || that_present_scx) {
+      if (this_present_utx || that_present_utx) {
-        if (!(this_present_scx && that_present_scx))
+        if (!(this_present_utx && that_present_utx))
           return false;
-        if (!this.scx.equals(that.scx))
+        if (!this.utx.equals(that.utx))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(createCart_result other) {
+    public int compareTo(createMasterAffiliate_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      createCart_result typedOther = (createCart_result)other;
+      createMasterAffiliate_result typedOther = (createMasterAffiliate_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(isSetScx()).compareTo(isSetScx());
+      lastComparison = Boolean.valueOf(isSetUtx()).compareTo(isSetUtx());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
             case SUCCESS:
-              if (field.type == TType.I64) {
+              if (field.type == TType.STRUCT) {
-                this.success = iprot.readI64();
+                this.success = new MasterAffiliate();
-                setSuccessIsSet(true);
+                this.success.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case SCX:
+            case UTX:
               if (field.type == TType.STRUCT) {
-                this.scx = new ShoppingCartException();
+                this.utx = new UserTrackerException();
-                this.scx.read(iprot);
+                this.utx.read(iprot);
               } 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.writeI64(this.success);
+        this.success.write(oprot);
         oprot.writeFieldEnd();
-      } else if (this.isSetScx()) {
+      } else if (this.isSetUtx()) {
-        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
-        this.scx.write(oprot);
+        this.utx.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("createCart_result(");
+      StringBuilder sb = new StringBuilder("createMasterAffiliate_result(");
       boolean first = true;
       sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
-      sb.append(this.success);
+        sb.append(this.success);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("scx:");
+      sb.append("utx:");
-      if (this.scx == null) {
+      if (this.utx == null) {
         sb.append("null");
       } else {
-        sb.append(this.scx);
+        sb.append(this.utx);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCurrentCart_args implements TBase<getCurrentCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCurrentCart_args>   {
+  public static class getMasterAffiliateById_args implements TBase<getMasterAffiliateById_args._Fields>, java.io.Serializable, Cloneable, Comparable<getMasterAffiliateById_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCurrentCart_args");
+    private static final TStruct STRUCT_DESC = new TStruct("getMasterAffiliateById_args");
-    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
+    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);
-    private long userId;
+    private long id;
     /** 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");
+      ID((short)1, "id");
       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 __USERID_ISSET_ID = 0;
+    private static final int __ID_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.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+      put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCurrentCart_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getMasterAffiliateById_args.class, metaDataMap);
+    }
-    public getCurrentCart_args() {
+    public getMasterAffiliateById_args() {
+    }
-    public getCurrentCart_args(
+    public getMasterAffiliateById_args(
-      long userId)
+      long id)
+    {
       this();
-      this.userId = userId;
+      this.id = id;
-      setUserIdIsSet(true);
+      setIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCurrentCart_args(getCurrentCart_args other) {
+    public getMasterAffiliateById_args(getMasterAffiliateById_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
-      this.userId = other.userId;
+      this.id = other.id;
+    }
-    public getCurrentCart_args deepCopy() {
+    public getMasterAffiliateById_args deepCopy() {
-      return new getCurrentCart_args(this);
+      return new getMasterAffiliateById_args(this);
+    }
     @Deprecated
-    public getCurrentCart_args clone() {
+    public getMasterAffiliateById_args clone() {
-      return new getCurrentCart_args(this);
+      return new getMasterAffiliateById_args(this);
+    }
-    public long getUserId() {
+    public long getId() {
-      return this.userId;
+      return this.id;
+    }
-    public getCurrentCart_args setUserId(long userId) {
+    public getMasterAffiliateById_args setId(long id) {
-      this.userId = userId;
+      this.id = id;
-      setUserIdIsSet(true);
+      setIdIsSet(true);
       return this;
+    }
-    public void unsetUserId() {
+    public void unsetId() {
-      __isset_bit_vector.clear(__USERID_ISSET_ID);
+      __isset_bit_vector.clear(__ID_ISSET_ID);
+    }
-    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    /** Returns true if field id is set (has been asigned a value) and false otherwise */
-    public boolean isSetUserId() {
+    public boolean isSetId() {
-      return __isset_bit_vector.get(__USERID_ISSET_ID);
+      return __isset_bit_vector.get(__ID_ISSET_ID);
+    }
-    public void setUserIdIsSet(boolean value) {
+    public void setIdIsSet(boolean value) {
-      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+      __isset_bit_vector.set(__ID_ISSET_ID, value);
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case USER_ID:
+      case ID:
         if (value == null) {
-          unsetUserId();
+          unsetId();
         } else {
-          setUserId((Long)value);
+          setId((Long)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case USER_ID:
+      case ID:
-        return new Long(getUserId());
+        return new Long(getId());
+      }
       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 USER_ID:
+      case ID:
-        return isSetUserId();
+        return isSetId();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCurrentCart_args)
+      if (that instanceof getMasterAffiliateById_args)
-        return this.equals((getCurrentCart_args)that);
+        return this.equals((getMasterAffiliateById_args)that);
       return false;
+    }
-    public boolean equals(getCurrentCart_args that) {
+    public boolean equals(getMasterAffiliateById_args that) {
       if (that == null)
         return false;
-      boolean this_present_userId = true;
+      boolean this_present_id = true;
-      boolean that_present_userId = true;
+      boolean that_present_id = true;
-      if (this_present_userId || that_present_userId) {
+      if (this_present_id || that_present_id) {
-        if (!(this_present_userId && that_present_userId))
+        if (!(this_present_id && that_present_id))
           return false;
-        if (this.userId != that.userId)
+        if (this.id != that.id)
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCurrentCart_args other) {
+    public int compareTo(getMasterAffiliateById_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCurrentCart_args typedOther = (getCurrentCart_args)other;
+      getMasterAffiliateById_args typedOther = (getMasterAffiliateById_args)other;
-      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      lastComparison = TBaseHelper.compareTo(id, typedOther.id);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case USER_ID:
+            case ID:
               if (field.type == TType.I64) {
-                this.userId = iprot.readI64();
+                this.id = iprot.readI64();
-                setUserIdIsSet(true);
+                setIdIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
-      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
+      oprot.writeFieldBegin(ID_FIELD_DESC);
-      oprot.writeI64(this.userId);
+      oprot.writeI64(this.id);
       oprot.writeFieldEnd();
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCurrentCart_args(");
+      StringBuilder sb = new StringBuilder("getMasterAffiliateById_args(");
       boolean first = true;
-      sb.append("userId:");
+      sb.append("id:");
-      sb.append(this.userId);
+      sb.append(this.id);
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCurrentCart_result implements TBase<getCurrentCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCurrentCart_result>   {
+  public static class getMasterAffiliateById_result implements TBase<getMasterAffiliateById_result._Fields>, java.io.Serializable, Cloneable, Comparable<getMasterAffiliateById_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCurrentCart_result");
+    private static final TStruct STRUCT_DESC = new TStruct("getMasterAffiliateById_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
-    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
-    private Cart success;
+    private MasterAffiliate success;
-    private ShoppingCartException scx;
+    private UserTrackerException utx;
     /** 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"),
-      SCX((short)1, "scx");
+      UTX((short)1, "utx");
       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
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
-          new StructMetaData(TType.STRUCT, Cart.class)));
+          new StructMetaData(TType.STRUCT, MasterAffiliate.class)));
-      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCurrentCart_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getMasterAffiliateById_result.class, metaDataMap);
+    }
-    public getCurrentCart_result() {
+    public getMasterAffiliateById_result() {
+    }
-    public getCurrentCart_result(
+    public getMasterAffiliateById_result(
-      Cart success,
+      MasterAffiliate success,
-      ShoppingCartException scx)
+      UserTrackerException utx)
+    {
       this();
       this.success = success;
-      this.scx = scx;
+      this.utx = utx;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCurrentCart_result(getCurrentCart_result other) {
+    public getMasterAffiliateById_result(getMasterAffiliateById_result other) {
       if (other.isSetSuccess()) {
-        this.success = new Cart(other.success);
+        this.success = new MasterAffiliate(other.success);
+      }
-      if (other.isSetScx()) {
+      if (other.isSetUtx()) {
-        this.scx = new ShoppingCartException(other.scx);
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
-    public getCurrentCart_result deepCopy() {
+    public getMasterAffiliateById_result deepCopy() {
-      return new getCurrentCart_result(this);
+      return new getMasterAffiliateById_result(this);
+    }
     @Deprecated
-    public getCurrentCart_result clone() {
+    public getMasterAffiliateById_result clone() {
-      return new getCurrentCart_result(this);
+      return new getMasterAffiliateById_result(this);
+    }
-    public Cart getSuccess() {
+    public MasterAffiliate getSuccess() {
       return this.success;
+    }
-    public getCurrentCart_result setSuccess(Cart success) {
+    public getMasterAffiliateById_result setSuccess(MasterAffiliate success) {
       this.success = success;
       return this;
+    }
     public void unsetSuccess() {
       if (!value) {
         this.success = null;
+      }
+    }
-    public ShoppingCartException getScx() {
+    public UserTrackerException getUtx() {
-      return this.scx;
+      return this.utx;
+    }
-    public getCurrentCart_result setScx(ShoppingCartException scx) {
+    public getMasterAffiliateById_result setUtx(UserTrackerException utx) {
-      this.scx = scx;
+      this.utx = utx;
       return this;
+    }
-    public void unsetScx() {
+    public void unsetUtx() {
-      this.scx = null;
+      this.utx = null;
+    }
-    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
-    public boolean isSetScx() {
+    public boolean isSetUtx() {
-      return this.scx != null;
+      return this.utx != null;
+    }
-    public void setScxIsSet(boolean value) {
+    public void setUtxIsSet(boolean value) {
       if (!value) {
-        this.scx = null;
+        this.utx = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((Cart)value);
+          setSuccess((MasterAffiliate)value);
+        }
         break;
-      case SCX:
+      case UTX:
         if (value == null) {
-          unsetScx();
+          unsetUtx();
         } else {
-          setScx((ShoppingCartException)value);
+          setUtx((UserTrackerException)value);
+        }
         break;
+      }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
-      case SCX:
+      case UTX:
-        return getScx();
+        return getUtx();
+      }
       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 SUCCESS:
         return isSetSuccess();
-      case SCX:
+      case UTX:
-        return isSetScx();
+        return isSetUtx();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCurrentCart_result)
+      if (that instanceof getMasterAffiliateById_result)
-        return this.equals((getCurrentCart_result)that);
+        return this.equals((getMasterAffiliateById_result)that);
       return false;
+    }
-    public boolean equals(getCurrentCart_result that) {
+    public boolean equals(getMasterAffiliateById_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
           return false;
         if (!this.success.equals(that.success))
           return false;
+      }
-      boolean this_present_scx = true && this.isSetScx();
+      boolean this_present_utx = true && this.isSetUtx();
-      boolean that_present_scx = true && that.isSetScx();
+      boolean that_present_utx = true && that.isSetUtx();
-      if (this_present_scx || that_present_scx) {
+      if (this_present_utx || that_present_utx) {
-        if (!(this_present_scx && that_present_scx))
+        if (!(this_present_utx && that_present_utx))
           return false;
-        if (!this.scx.equals(that.scx))
+        if (!this.utx.equals(that.utx))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCurrentCart_result other) {
+    public int compareTo(getMasterAffiliateById_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCurrentCart_result typedOther = (getCurrentCart_result)other;
+      getMasterAffiliateById_result typedOther = (getMasterAffiliateById_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(isSetScx()).compareTo(isSetScx());
+      lastComparison = Boolean.valueOf(isSetUtx()).compareTo(isSetUtx());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.STRUCT) {
-                this.success = new Cart();
+                this.success = new MasterAffiliate();
                 this.success.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case SCX:
+            case UTX:
               if (field.type == TType.STRUCT) {
-                this.scx = new ShoppingCartException();
+                this.utx = new UserTrackerException();
-                this.scx.read(iprot);
+                this.utx.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         this.success.write(oprot);
         oprot.writeFieldEnd();
-      } else if (this.isSetScx()) {
+      } else if (this.isSetUtx()) {
-        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
-        this.scx.write(oprot);
+        this.utx.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCurrentCart_result(");
+      StringBuilder sb = new StringBuilder("getMasterAffiliateById_result(");
       boolean first = true;
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("scx:");
+      sb.append("utx:");
-      if (this.scx == null) {
+      if (this.utx == null) {
         sb.append("null");
       } else {
-        sb.append(this.scx);
+        sb.append(this.utx);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCart_args implements TBase<getCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCart_args>   {
+  public static class getMasterAffiliateByName_args implements TBase<getMasterAffiliateByName_args._Fields>, java.io.Serializable, Cloneable, Comparable<getMasterAffiliateByName_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCart_args");
+    private static final TStruct STRUCT_DESC = new TStruct("getMasterAffiliateByName_args");
-    private static final TField CART_ID_FIELD_DESC = new TField("cartId", TType.I64, (short)1);
+    private static final TField NAME_FIELD_DESC = new TField("name", TType.STRING, (short)1);
-    private long cartId;
+    private String name;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
-      CART_ID((short)1, "cartId");
+      NAME((short)1, "name");
       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 __CARTID_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.CART_ID, new FieldMetaData("cartId", TFieldRequirementType.DEFAULT,
+      put(_Fields.NAME, new FieldMetaData("name", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.I64)));
+          new FieldValueMetaData(TType.STRING)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCart_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getMasterAffiliateByName_args.class, metaDataMap);
+    }
-    public getCart_args() {
+    public getMasterAffiliateByName_args() {
+    }
-    public getCart_args(
+    public getMasterAffiliateByName_args(
-      long cartId)
+      String name)
+    {
       this();
-      this.cartId = cartId;
+      this.name = name;
-      setCartIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCart_args(getCart_args other) {
+    public getMasterAffiliateByName_args(getMasterAffiliateByName_args other) {
-      __isset_bit_vector.clear();
+      if (other.isSetName()) {
-      __isset_bit_vector.or(other.__isset_bit_vector);
-      this.cartId = other.cartId;
+        this.name = other.name;
+      }
+    }
-    public getCart_args deepCopy() {
+    public getMasterAffiliateByName_args deepCopy() {
-      return new getCart_args(this);
+      return new getMasterAffiliateByName_args(this);
+    }
     @Deprecated
-    public getCart_args clone() {
+    public getMasterAffiliateByName_args clone() {
-      return new getCart_args(this);
+      return new getMasterAffiliateByName_args(this);
+    }
-    public long getCartId() {
+    public String getName() {
-      return this.cartId;
+      return this.name;
+    }
-    public getCart_args setCartId(long cartId) {
+    public getMasterAffiliateByName_args setName(String name) {
-      this.cartId = cartId;
+      this.name = name;
-      setCartIdIsSet(true);
       return this;
+    }
-    public void unsetCartId() {
+    public void unsetName() {
-      __isset_bit_vector.clear(__CARTID_ISSET_ID);
+      this.name = null;
+    }
-    /** Returns true if field cartId is set (has been asigned a value) and false otherwise */
+    /** Returns true if field name is set (has been asigned a value) and false otherwise */
-    public boolean isSetCartId() {
+    public boolean isSetName() {
-      return __isset_bit_vector.get(__CARTID_ISSET_ID);
+      return this.name != null;
+    }
-    public void setCartIdIsSet(boolean value) {
+    public void setNameIsSet(boolean value) {
+      if (!value) {
-      __isset_bit_vector.set(__CARTID_ISSET_ID, value);
+        this.name = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case CART_ID:
+      case NAME:
         if (value == null) {
-          unsetCartId();
+          unsetName();
         } else {
-          setCartId((Long)value);
+          setName((String)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case CART_ID:
+      case NAME:
-        return new Long(getCartId());
+        return getName();
+      }
       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 CART_ID:
+      case NAME:
-        return isSetCartId();
+        return isSetName();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCart_args)
+      if (that instanceof getMasterAffiliateByName_args)
-        return this.equals((getCart_args)that);
+        return this.equals((getMasterAffiliateByName_args)that);
       return false;
+    }
-    public boolean equals(getCart_args that) {
+    public boolean equals(getMasterAffiliateByName_args that) {
       if (that == null)
         return false;
-      boolean this_present_cartId = true;
+      boolean this_present_name = true && this.isSetName();
-      boolean that_present_cartId = true;
+      boolean that_present_name = true && that.isSetName();
-      if (this_present_cartId || that_present_cartId) {
+      if (this_present_name || that_present_name) {
-        if (!(this_present_cartId && that_present_cartId))
+        if (!(this_present_name && that_present_name))
           return false;
-        if (this.cartId != that.cartId)
+        if (!this.name.equals(that.name))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCart_args other) {
+    public int compareTo(getMasterAffiliateByName_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCart_args typedOther = (getCart_args)other;
+      getMasterAffiliateByName_args typedOther = (getMasterAffiliateByName_args)other;
-      lastComparison = Boolean.valueOf(isSetCartId()).compareTo(isSetCartId());
+      lastComparison = Boolean.valueOf(isSetName()).compareTo(isSetName());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(cartId, typedOther.cartId);
+      lastComparison = TBaseHelper.compareTo(name, typedOther.name);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case CART_ID:
+            case NAME:
-              if (field.type == TType.I64) {
+              if (field.type == TType.STRING) {
-                this.cartId = iprot.readI64();
+                this.name = iprot.readString();
-                setCartIdIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
+      if (this.name != null) {
-      oprot.writeFieldBegin(CART_ID_FIELD_DESC);
+        oprot.writeFieldBegin(NAME_FIELD_DESC);
-      oprot.writeI64(this.cartId);
+        oprot.writeString(this.name);
-      oprot.writeFieldEnd();
+        oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCart_args(");
+      StringBuilder sb = new StringBuilder("getMasterAffiliateByName_args(");
       boolean first = true;
-      sb.append("cartId:");
+      sb.append("name:");
+      if (this.name == null) {
+        sb.append("null");
+      } else {
-      sb.append(this.cartId);
+        sb.append(this.name);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCart_result implements TBase<getCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCart_result>   {
+  public static class getMasterAffiliateByName_result implements TBase<getMasterAffiliateByName_result._Fields>, java.io.Serializable, Cloneable, Comparable<getMasterAffiliateByName_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCart_result");
+    private static final TStruct STRUCT_DESC = new TStruct("getMasterAffiliateByName_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
-    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
-    private Cart success;
+    private MasterAffiliate success;
-    private ShoppingCartException scx;
+    private UserTrackerException utx;
     /** 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"),
-      SCX((short)1, "scx");
+      UTX((short)1, "utx");
       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
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
-          new StructMetaData(TType.STRUCT, Cart.class)));
+          new StructMetaData(TType.STRUCT, MasterAffiliate.class)));
-      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCart_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getMasterAffiliateByName_result.class, metaDataMap);
+    }
-    public getCart_result() {
+    public getMasterAffiliateByName_result() {
+    }
-    public getCart_result(
+    public getMasterAffiliateByName_result(
-      Cart success,
+      MasterAffiliate success,
-      ShoppingCartException scx)
+      UserTrackerException utx)
+    {
       this();
       this.success = success;
-      this.scx = scx;
+      this.utx = utx;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCart_result(getCart_result other) {
+    public getMasterAffiliateByName_result(getMasterAffiliateByName_result other) {
       if (other.isSetSuccess()) {
-        this.success = new Cart(other.success);
+        this.success = new MasterAffiliate(other.success);
+      }
-      if (other.isSetScx()) {
+      if (other.isSetUtx()) {
-        this.scx = new ShoppingCartException(other.scx);
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
-    public getCart_result deepCopy() {
+    public getMasterAffiliateByName_result deepCopy() {
-      return new getCart_result(this);
+      return new getMasterAffiliateByName_result(this);
+    }
     @Deprecated
-    public getCart_result clone() {
+    public getMasterAffiliateByName_result clone() {
-      return new getCart_result(this);
+      return new getMasterAffiliateByName_result(this);
+    }
-    public Cart getSuccess() {
+    public MasterAffiliate getSuccess() {
       return this.success;
+    }
-    public getCart_result setSuccess(Cart success) {
+    public getMasterAffiliateByName_result setSuccess(MasterAffiliate success) {
       this.success = success;
       return this;
+    }
     public void unsetSuccess() {
       if (!value) {
         this.success = null;
+      }
+    }
-    public ShoppingCartException getScx() {
+    public UserTrackerException getUtx() {
-      return this.scx;
+      return this.utx;
+    }
-    public getCart_result setScx(ShoppingCartException scx) {
+    public getMasterAffiliateByName_result setUtx(UserTrackerException utx) {
-      this.scx = scx;
+      this.utx = utx;
       return this;
+    }
-    public void unsetScx() {
+    public void unsetUtx() {
-      this.scx = null;
+      this.utx = null;
+    }
-    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
-    public boolean isSetScx() {
+    public boolean isSetUtx() {
-      return this.scx != null;
+      return this.utx != null;
+    }
-    public void setScxIsSet(boolean value) {
+    public void setUtxIsSet(boolean value) {
       if (!value) {
-        this.scx = null;
+        this.utx = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((Cart)value);
+          setSuccess((MasterAffiliate)value);
+        }
         break;
-      case SCX:
+      case UTX:
         if (value == null) {
-          unsetScx();
+          unsetUtx();
         } else {
-          setScx((ShoppingCartException)value);
+          setUtx((UserTrackerException)value);
+        }
         break;
+      }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
-      case SCX:
+      case UTX:
-        return getScx();
+        return getUtx();
+      }
       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 SUCCESS:
         return isSetSuccess();
-      case SCX:
+      case UTX:
-        return isSetScx();
+        return isSetUtx();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCart_result)
+      if (that instanceof getMasterAffiliateByName_result)
-        return this.equals((getCart_result)that);
+        return this.equals((getMasterAffiliateByName_result)that);
       return false;
+    }
-    public boolean equals(getCart_result that) {
+    public boolean equals(getMasterAffiliateByName_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
           return false;
         if (!this.success.equals(that.success))
           return false;
+      }
-      boolean this_present_scx = true && this.isSetScx();
+      boolean this_present_utx = true && this.isSetUtx();
-      boolean that_present_scx = true && that.isSetScx();
+      boolean that_present_utx = true && that.isSetUtx();
-      if (this_present_scx || that_present_scx) {
+      if (this_present_utx || that_present_utx) {
-        if (!(this_present_scx && that_present_scx))
+        if (!(this_present_utx && that_present_utx))
           return false;
-        if (!this.scx.equals(that.scx))
+        if (!this.utx.equals(that.utx))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCart_result other) {
+    public int compareTo(getMasterAffiliateByName_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCart_result typedOther = (getCart_result)other;
+      getMasterAffiliateByName_result typedOther = (getMasterAffiliateByName_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(isSetScx()).compareTo(isSetScx());
+      lastComparison = Boolean.valueOf(isSetUtx()).compareTo(isSetUtx());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.STRUCT) {
-                this.success = new Cart();
+                this.success = new MasterAffiliate();
                 this.success.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case SCX:
+            case UTX:
               if (field.type == TType.STRUCT) {
-                this.scx = new ShoppingCartException();
+                this.utx = new UserTrackerException();
-                this.scx.read(iprot);
+                this.utx.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         this.success.write(oprot);
         oprot.writeFieldEnd();
-      } else if (this.isSetScx()) {
+      } else if (this.isSetUtx()) {
-        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
-        this.scx.write(oprot);
+        this.utx.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCart_result(");
+      StringBuilder sb = new StringBuilder("getMasterAffiliateByName_result(");
       boolean first = true;
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("scx:");
+      sb.append("utx:");
-      if (this.scx == null) {
+      if (this.utx == null) {
         sb.append("null");
       } else {
-        sb.append(this.scx);
+        sb.append(this.utx);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCartsForUser_args implements TBase<getCartsForUser_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsForUser_args>   {
+  public static class createAffiliate_args implements TBase<createAffiliate_args._Fields>, java.io.Serializable, Cloneable, Comparable<createAffiliate_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCartsForUser_args");
+    private static final TStruct STRUCT_DESC = new TStruct("createAffiliate_args");
-    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
+    private static final TField NAME_FIELD_DESC = new TField("name", TType.STRING, (short)1);
-    private static final TField STATUS_FIELD_DESC = new TField("status", TType.I32, (short)2);
+    private static final TField URL_FIELD_DESC = new TField("url", TType.STRING, (short)2);
+    private static final TField MASTER_AFFILIATE_ID_FIELD_DESC = new TField("masterAffiliateId", TType.I64, (short)3);
+    private String name;
-    private long userId;
+    private String url;
-    private CartStatus status;
+    private long masterAffiliateId;
     /** 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"),
+      NAME((short)1, "name"),
-      /**
-       *
-       * @see CartStatus
+      URL((short)2, "url"),
-       */
-      STATUS((short)2, "status");
+      MASTER_AFFILIATE_ID((short)3, "masterAffiliateId");
       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 __USERID_ISSET_ID = 0;
+    private static final int __MASTERAFFILIATEID_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.NAME, new FieldMetaData("name", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
-      put(_Fields.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+      put(_Fields.URL, new FieldMetaData("url", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
+      put(_Fields.MASTER_AFFILIATE_ID, new FieldMetaData("masterAffiliateId", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
-      put(_Fields.STATUS, new FieldMetaData("status", TFieldRequirementType.DEFAULT,
-          new EnumMetaData(TType.ENUM, CartStatus.class)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCartsForUser_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(createAffiliate_args.class, metaDataMap);
+    }
-    public getCartsForUser_args() {
+    public createAffiliate_args() {
+    }
-    public getCartsForUser_args(
+    public createAffiliate_args(
+      String name,
-      long userId,
+      String url,
-      CartStatus status)
+      long masterAffiliateId)
+    {
       this();
-      this.userId = userId;
+      this.name = name;
-      setUserIdIsSet(true);
+      this.url = url;
-      this.status = status;
+      this.masterAffiliateId = masterAffiliateId;
+      setMasterAffiliateIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCartsForUser_args(getCartsForUser_args other) {
+    public createAffiliate_args(createAffiliate_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
-      this.userId = other.userId;
-      if (other.isSetStatus()) {
+      if (other.isSetName()) {
-        this.status = other.status;
+        this.name = other.name;
+      }
+      if (other.isSetUrl()) {
+        this.url = other.url;
+      }
+      this.masterAffiliateId = other.masterAffiliateId;
+    }
-    public getCartsForUser_args deepCopy() {
+    public createAffiliate_args deepCopy() {
-      return new getCartsForUser_args(this);
+      return new createAffiliate_args(this);
+    }
     @Deprecated
-    public getCartsForUser_args clone() {
+    public createAffiliate_args clone() {
-      return new getCartsForUser_args(this);
+      return new createAffiliate_args(this);
+    }
-    public long getUserId() {
+    public String getName() {
-      return this.userId;
+      return this.name;
+    }
-    public getCartsForUser_args setUserId(long userId) {
+    public createAffiliate_args setName(String name) {
-      this.userId = userId;
+      this.name = name;
-      setUserIdIsSet(true);
       return this;
+    }
-    public void unsetUserId() {
+    public void unsetName() {
-      __isset_bit_vector.clear(__USERID_ISSET_ID);
+      this.name = null;
+    }
-    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    /** Returns true if field name is set (has been asigned a value) and false otherwise */
-    public boolean isSetUserId() {
+    public boolean isSetName() {
-      return __isset_bit_vector.get(__USERID_ISSET_ID);
+      return this.name != null;
+    }
-    public void setUserIdIsSet(boolean value) {
+    public void setNameIsSet(boolean value) {
+      if (!value) {
-      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+        this.name = null;
+      }
+    }
-    /**
-     *
-     * @see CartStatus
-     */
-    public CartStatus getStatus() {
+    public String getUrl() {
-      return this.status;
+      return this.url;
+    }
-    /**
-     *
-     * @see CartStatus
-     */
-    public getCartsForUser_args setStatus(CartStatus status) {
+    public createAffiliate_args setUrl(String url) {
-      this.status = status;
+      this.url = url;
       return this;
+    }
-    public void unsetStatus() {
+    public void unsetUrl() {
-      this.status = null;
+      this.url = null;
+    }
-    /** Returns true if field status is set (has been asigned a value) and false otherwise */
+    /** Returns true if field url is set (has been asigned a value) and false otherwise */
-    public boolean isSetStatus() {
+    public boolean isSetUrl() {
-      return this.status != null;
+      return this.url != null;
+    }
-    public void setStatusIsSet(boolean value) {
+    public void setUrlIsSet(boolean value) {
       if (!value) {
-        this.status = null;
+        this.url = null;
+      }
+    }
+    public long getMasterAffiliateId() {
+      return this.masterAffiliateId;
+    }
+    public createAffiliate_args setMasterAffiliateId(long masterAffiliateId) {
+      this.masterAffiliateId = masterAffiliateId;
+      setMasterAffiliateIdIsSet(true);
+      return this;
+    }
+    public void unsetMasterAffiliateId() {
+      __isset_bit_vector.clear(__MASTERAFFILIATEID_ISSET_ID);
+    }
+    /** Returns true if field masterAffiliateId is set (has been asigned a value) and false otherwise */
+    public boolean isSetMasterAffiliateId() {
+      return __isset_bit_vector.get(__MASTERAFFILIATEID_ISSET_ID);
+    }
+    public void setMasterAffiliateIdIsSet(boolean value) {
+      __isset_bit_vector.set(__MASTERAFFILIATEID_ISSET_ID, value);
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case USER_ID:
+      case NAME:
         if (value == null) {
-          unsetUserId();
+          unsetName();
         } else {
-          setUserId((Long)value);
+          setName((String)value);
+        }
         break;
-      case STATUS:
+      case URL:
         if (value == null) {
-          unsetStatus();
+          unsetUrl();
         } else {
-          setStatus((CartStatus)value);
+          setUrl((String)value);
+        }
+        break;
+      case MASTER_AFFILIATE_ID:
+        if (value == null) {
+          unsetMasterAffiliateId();
+        } else {
+          setMasterAffiliateId((Long)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case USER_ID:
+      case NAME:
-        return new Long(getUserId());
+        return getName();
-      case STATUS:
+      case URL:
-        return getStatus();
+        return getUrl();
+      case MASTER_AFFILIATE_ID:
+        return new Long(getMasterAffiliateId());
+      }
       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 USER_ID:
+      case NAME:
-        return isSetUserId();
+        return isSetName();
-      case STATUS:
+      case URL:
-        return isSetStatus();
+        return isSetUrl();
+      case MASTER_AFFILIATE_ID:
+        return isSetMasterAffiliateId();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCartsForUser_args)
+      if (that instanceof createAffiliate_args)
-        return this.equals((getCartsForUser_args)that);
+        return this.equals((createAffiliate_args)that);
       return false;
+    }
-    public boolean equals(getCartsForUser_args that) {
+    public boolean equals(createAffiliate_args that) {
       if (that == null)
         return false;
-      boolean this_present_userId = true;
+      boolean this_present_name = true && this.isSetName();
-      boolean that_present_userId = true;
+      boolean that_present_name = true && that.isSetName();
-      if (this_present_userId || that_present_userId) {
+      if (this_present_name || that_present_name) {
-        if (!(this_present_userId && that_present_userId))
+        if (!(this_present_name && that_present_name))
           return false;
-        if (this.userId != that.userId)
+        if (!this.name.equals(that.name))
           return false;
+      }
-      boolean this_present_status = true && this.isSetStatus();
+      boolean this_present_url = true && this.isSetUrl();
-      boolean that_present_status = true && that.isSetStatus();
+      boolean that_present_url = true && that.isSetUrl();
-      if (this_present_status || that_present_status) {
+      if (this_present_url || that_present_url) {
-        if (!(this_present_status && that_present_status))
+        if (!(this_present_url && that_present_url))
           return false;
-        if (!this.status.equals(that.status))
+        if (!this.url.equals(that.url))
+          return false;
+      }
+      boolean this_present_masterAffiliateId = true;
+      boolean that_present_masterAffiliateId = true;
+      if (this_present_masterAffiliateId || that_present_masterAffiliateId) {
+        if (!(this_present_masterAffiliateId && that_present_masterAffiliateId))
+          return false;
+        if (this.masterAffiliateId != that.masterAffiliateId)
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCartsForUser_args other) {
+    public int compareTo(createAffiliate_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCartsForUser_args typedOther = (getCartsForUser_args)other;
+      createAffiliate_args typedOther = (createAffiliate_args)other;
-      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      lastComparison = Boolean.valueOf(isSetName()).compareTo(isSetName());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      lastComparison = TBaseHelper.compareTo(name, typedOther.name);
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = Boolean.valueOf(isSetStatus()).compareTo(isSetStatus());
+      lastComparison = Boolean.valueOf(isSetUrl()).compareTo(isSetUrl());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(status, typedOther.status);
+      lastComparison = TBaseHelper.compareTo(url, typedOther.url);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetMasterAffiliateId()).compareTo(isSetMasterAffiliateId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(masterAffiliateId, typedOther.masterAffiliateId);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case USER_ID:
+            case NAME:
-              if (field.type == TType.I64) {
+              if (field.type == TType.STRING) {
-                this.userId = iprot.readI64();
+                this.name = iprot.readString();
-                setUserIdIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case STATUS:
+            case URL:
+              if (field.type == TType.STRING) {
+                this.url = iprot.readString();
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case MASTER_AFFILIATE_ID:
-              if (field.type == TType.I32) {
+              if (field.type == TType.I64) {
-                this.status = CartStatus.findByValue(iprot.readI32());
+                this.masterAffiliateId = iprot.readI64();
+                setMasterAffiliateIdIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
-      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
-      oprot.writeI64(this.userId);
-      oprot.writeFieldEnd();
-      if (this.status != null) {
+      if (this.name != null) {
-        oprot.writeFieldBegin(STATUS_FIELD_DESC);
+        oprot.writeFieldBegin(NAME_FIELD_DESC);
-        oprot.writeI32(this.status.getValue());
+        oprot.writeString(this.name);
         oprot.writeFieldEnd();
+      }
+      if (this.url != null) {
+        oprot.writeFieldBegin(URL_FIELD_DESC);
+        oprot.writeString(this.url);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(MASTER_AFFILIATE_ID_FIELD_DESC);
+      oprot.writeI64(this.masterAffiliateId);
+      oprot.writeFieldEnd();
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCartsForUser_args(");
+      StringBuilder sb = new StringBuilder("createAffiliate_args(");
       boolean first = true;
-      sb.append("userId:");
+      sb.append("name:");
+      if (this.name == null) {
+        sb.append("null");
+      } else {
-      sb.append(this.userId);
+        sb.append(this.name);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("status:");
+      sb.append("url:");
-      if (this.status == null) {
+      if (this.url == null) {
         sb.append("null");
       } else {
-        String status_name = status.name();
-        if (status_name != null) {
-          sb.append(status_name);
-          sb.append(" (");
-        }
-        sb.append(this.status);
+        sb.append(this.url);
-        if (status_name != null) {
-          sb.append(")");
-        }
+      }
       first = false;
+      if (!first) sb.append(", ");
+      sb.append("masterAffiliateId:");
+      sb.append(this.masterAffiliateId);
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws TException {
       // check for required fields
+    }
+  }
-  public static class getCartsForUser_result implements TBase<getCartsForUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsForUser_result>   {
+  public static class createAffiliate_result implements TBase<createAffiliate_result._Fields>, java.io.Serializable, Cloneable, Comparable<createAffiliate_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCartsForUser_result");
+    private static final TStruct STRUCT_DESC = new TStruct("createAffiliate_result");
-    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
-    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
-    private List<Cart> success;
+    private Affiliate success;
-    private ShoppingCartException scx;
+    private UserTrackerException utx;
     /** 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"),
-      SCX((short)1, "scx");
+      UTX((short)1, "utx");
       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
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
-          new ListMetaData(TType.LIST,
-              new StructMetaData(TType.STRUCT, Cart.class))));
+          new StructMetaData(TType.STRUCT, Affiliate.class)));
-      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCartsForUser_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(createAffiliate_result.class, metaDataMap);
+    }
-    public getCartsForUser_result() {
+    public createAffiliate_result() {
+    }
-    public getCartsForUser_result(
+    public createAffiliate_result(
-      List<Cart> success,
+      Affiliate success,
-      ShoppingCartException scx)
+      UserTrackerException utx)
+    {
       this();
       this.success = success;
-      this.scx = scx;
+      this.utx = utx;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCartsForUser_result(getCartsForUser_result other) {
+    public createAffiliate_result(createAffiliate_result other) {
       if (other.isSetSuccess()) {
-        List<Cart> __this__success = new ArrayList<Cart>();
-        for (Cart other_element : other.success) {
-          __this__success.add(new Cart(other_element));
-        }
-        this.success = __this__success;
+        this.success = new Affiliate(other.success);
+      }
-      if (other.isSetScx()) {
+      if (other.isSetUtx()) {
-        this.scx = new ShoppingCartException(other.scx);
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
-    public getCartsForUser_result deepCopy() {
+    public createAffiliate_result deepCopy() {
-      return new getCartsForUser_result(this);
+      return new createAffiliate_result(this);
+    }
     @Deprecated
-    public getCartsForUser_result clone() {
+    public createAffiliate_result clone() {
-      return new getCartsForUser_result(this);
+      return new createAffiliate_result(this);
+    }
-    public int getSuccessSize() {
+    public Affiliate getSuccess() {
-      return (this.success == null) ? 0 : this.success.size();
+      return this.success;
+    }
-    public java.util.Iterator<Cart> getSuccessIterator() {
+    public createAffiliate_result setSuccess(Affiliate success) {
-      return (this.success == null) ? null : this.success.iterator();
+      this.success = success;
+      return this;
+    }
-    public void addToSuccess(Cart elem) {
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public createAffiliate_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Affiliate)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 createAffiliate_result)
+        return this.equals((createAffiliate_result)that);
+      return false;
+    }
+    public boolean equals(createAffiliate_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(createAffiliate_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createAffiliate_result typedOther = (createAffiliate_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 SUCCESS:
+              if (field.type == TType.STRUCT) {
+                this.success = new Affiliate();
+                this.success.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        this.success.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("createAffiliate_result(");
+      boolean first = true;
+      sb.append("success:");
       if (this.success == null) {
+        sb.append("null");
+      } else {
-        this.success = new ArrayList<Cart>();
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
-      this.success.add(elem);
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getAffiliateById_args implements TBase<getAffiliateById_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAffiliateById_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getAffiliateById_args");
+    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);
+    private long id;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      ID((short)1, "id");
+      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 __ID_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.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getAffiliateById_args.class, metaDataMap);
+    }
+    public getAffiliateById_args() {
+    }
+    public getAffiliateById_args(
+      long id)
+    {
+      this();
+      this.id = id;
+      setIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAffiliateById_args(getAffiliateById_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.id = other.id;
+    }
+    public getAffiliateById_args deepCopy() {
+      return new getAffiliateById_args(this);
+    }
+    @Deprecated
+    public getAffiliateById_args clone() {
+      return new getAffiliateById_args(this);
+    }
+    public long getId() {
+      return this.id;
+    }
+    public getAffiliateById_args setId(long id) {
+      this.id = id;
+      setIdIsSet(true);
+      return this;
+    }
+    public void unsetId() {
+      __isset_bit_vector.clear(__ID_ISSET_ID);
+    }
+    /** Returns true if field id is set (has been asigned a value) and false otherwise */
+    public boolean isSetId() {
+      return __isset_bit_vector.get(__ID_ISSET_ID);
+    }
+    public void setIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ID:
+        if (value == null) {
+          unsetId();
+        } else {
+          setId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ID:
+        return new Long(getId());
+      }
+      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 ID:
+        return isSetId();
+      }
+      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 getAffiliateById_args)
+        return this.equals((getAffiliateById_args)that);
+      return false;
+    }
+    public boolean equals(getAffiliateById_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_id = true;
+      boolean that_present_id = true;
+      if (this_present_id || that_present_id) {
+        if (!(this_present_id && that_present_id))
+          return false;
+        if (this.id != that.id)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getAffiliateById_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getAffiliateById_args typedOther = (getAffiliateById_args)other;
+      lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(id, typedOther.id);
+      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 ID:
+              if (field.type == TType.I64) {
+                this.id = iprot.readI64();
+                setIdIsSet(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(ID_FIELD_DESC);
+      oprot.writeI64(this.id);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getAffiliateById_args(");
+      boolean first = true;
+      sb.append("id:");
+      sb.append(this.id);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getAffiliateById_result implements TBase<getAffiliateById_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAffiliateById_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getAffiliateById_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private Affiliate success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new StructMetaData(TType.STRUCT, Affiliate.class)));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getAffiliateById_result.class, metaDataMap);
+    }
+    public getAffiliateById_result() {
+    }
+    public getAffiliateById_result(
+      Affiliate success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAffiliateById_result(getAffiliateById_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new Affiliate(other.success);
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public getAffiliateById_result deepCopy() {
+      return new getAffiliateById_result(this);
+    }
+    @Deprecated
+    public getAffiliateById_result clone() {
+      return new getAffiliateById_result(this);
+    }
-    public List<Cart> getSuccess() {
+    public Affiliate getSuccess() {
       return this.success;
+    }
-    public getCartsForUser_result setSuccess(List<Cart> success) {
+    public getAffiliateById_result setSuccess(Affiliate success) {
       this.success = success;
       return this;
+    }
     public void unsetSuccess() {
       if (!value) {
         this.success = null;
+      }
+    }
-    public ShoppingCartException getScx() {
+    public UserTrackerException getUtx() {
-      return this.scx;
+      return this.utx;
+    }
-    public getCartsForUser_result setScx(ShoppingCartException scx) {
+    public getAffiliateById_result setUtx(UserTrackerException utx) {
-      this.scx = scx;
+      this.utx = utx;
       return this;
+    }
-    public void unsetScx() {
+    public void unsetUtx() {
-      this.scx = null;
+      this.utx = null;
+    }
-    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
-    public boolean isSetScx() {
+    public boolean isSetUtx() {
-      return this.scx != null;
+      return this.utx != null;
+    }
-    public void setScxIsSet(boolean value) {
+    public void setUtxIsSet(boolean value) {
       if (!value) {
-        this.scx = null;
+        this.utx = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((List<Cart>)value);
+          setSuccess((Affiliate)value);
+        }
         break;
-      case SCX:
+      case UTX:
         if (value == null) {
-          unsetScx();
+          unsetUtx();
         } else {
-          setScx((ShoppingCartException)value);
+          setUtx((UserTrackerException)value);
+        }
         break;
+      }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
-      case SCX:
+      case UTX:
-        return getScx();
+        return getUtx();
+      }
       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 SUCCESS:
         return isSetSuccess();
-      case SCX:
+      case UTX:
-        return isSetScx();
+        return isSetUtx();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCartsForUser_result)
+      if (that instanceof getAffiliateById_result)
-        return this.equals((getCartsForUser_result)that);
+        return this.equals((getAffiliateById_result)that);
       return false;
+    }
-    public boolean equals(getCartsForUser_result that) {
+    public boolean equals(getAffiliateById_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
           return false;
         if (!this.success.equals(that.success))
           return false;
+      }
-      boolean this_present_scx = true && this.isSetScx();
+      boolean this_present_utx = true && this.isSetUtx();
-      boolean that_present_scx = true && that.isSetScx();
+      boolean that_present_utx = true && that.isSetUtx();
-      if (this_present_scx || that_present_scx) {
+      if (this_present_utx || that_present_utx) {
-        if (!(this_present_scx && that_present_scx))
+        if (!(this_present_utx && that_present_utx))
           return false;
-        if (!this.scx.equals(that.scx))
+        if (!this.utx.equals(that.utx))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCartsForUser_result other) {
+    public int compareTo(getAffiliateById_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCartsForUser_result typedOther = (getCartsForUser_result)other;
+      getAffiliateById_result typedOther = (getAffiliateById_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(isSetScx()).compareTo(isSetScx());
+      lastComparison = Boolean.valueOf(isSetUtx()).compareTo(isSetUtx());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
             case SUCCESS:
-              if (field.type == TType.LIST) {
+              if (field.type == TType.STRUCT) {
-                {
-                  TList _list28 = iprot.readListBegin();
-                  this.success = new ArrayList<Cart>(_list28.size);
+                this.success = new Affiliate();
-                  for (int _i29 = 0; _i29 < _list28.size; ++_i29)
-                  {
-                    Cart _elem30;
-                    _elem30 = new Cart();
-                    _elem30.read(iprot);
+                this.success.read(iprot);
-                    this.success.add(_elem30);
-                  }
-                  iprot.readListEnd();
-                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case SCX:
+            case UTX:
               if (field.type == TType.STRUCT) {
-                this.scx = new ShoppingCartException();
+                this.utx = new UserTrackerException();
-                this.scx.read(iprot);
+                this.utx.read(iprot);
               } 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.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Cart _iter31 : this.success)
-          {
-            _iter31.write(oprot);
+        this.success.write(oprot);
-          }
-          oprot.writeListEnd();
-        }
         oprot.writeFieldEnd();
-      } else if (this.isSetScx()) {
+      } else if (this.isSetUtx()) {
-        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
-        this.scx.write(oprot);
+        this.utx.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCartsForUser_result(");
+      StringBuilder sb = new StringBuilder("getAffiliateById_result(");
       boolean first = true;
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("scx:");
+      sb.append("utx:");
-      if (this.scx == null) {
+      if (this.utx == null) {
         sb.append("null");
       } else {
-        sb.append(this.scx);
+        sb.append(this.utx);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCartsByStatus_args implements TBase<getCartsByStatus_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByStatus_args>   {
+  public static class getAffiliateByName_args implements TBase<getAffiliateByName_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAffiliateByName_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCartsByStatus_args");
+    private static final TStruct STRUCT_DESC = new TStruct("getAffiliateByName_args");
-    private static final TField STATUS_FIELD_DESC = new TField("status", TType.I32, (short)1);
+    private static final TField NAME_FIELD_DESC = new TField("name", TType.STRING, (short)1);
-    private CartStatus status;
+    private String name;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
-      /**
-       *
-       * @see CartStatus
-       */
-      STATUS((short)1, "status");
+      NAME((short)1, "name");
       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
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
-      put(_Fields.STATUS, new FieldMetaData("status", TFieldRequirementType.DEFAULT,
+      put(_Fields.NAME, new FieldMetaData("name", TFieldRequirementType.DEFAULT,
-          new EnumMetaData(TType.ENUM, CartStatus.class)));
+          new FieldValueMetaData(TType.STRING)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCartsByStatus_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getAffiliateByName_args.class, metaDataMap);
+    }
-    public getCartsByStatus_args() {
+    public getAffiliateByName_args() {
+    }
-    public getCartsByStatus_args(
+    public getAffiliateByName_args(
-      CartStatus status)
+      String name)
+    {
       this();
-      this.status = status;
+      this.name = name;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCartsByStatus_args(getCartsByStatus_args other) {
+    public getAffiliateByName_args(getAffiliateByName_args other) {
-      if (other.isSetStatus()) {
+      if (other.isSetName()) {
-        this.status = other.status;
+        this.name = other.name;
+      }
+    }
-    public getCartsByStatus_args deepCopy() {
+    public getAffiliateByName_args deepCopy() {
-      return new getCartsByStatus_args(this);
+      return new getAffiliateByName_args(this);
+    }
     @Deprecated
-    public getCartsByStatus_args clone() {
+    public getAffiliateByName_args clone() {
-      return new getCartsByStatus_args(this);
+      return new getAffiliateByName_args(this);
+    }
-    /**
-     *
-     * @see CartStatus
-     */
-    public CartStatus getStatus() {
+    public String getName() {
-      return this.status;
+      return this.name;
+    }
-    /**
-     *
-     * @see CartStatus
-     */
-    public getCartsByStatus_args setStatus(CartStatus status) {
+    public getAffiliateByName_args setName(String name) {
-      this.status = status;
+      this.name = name;
       return this;
+    }
-    public void unsetStatus() {
+    public void unsetName() {
-      this.status = null;
+      this.name = null;
+    }
-    /** Returns true if field status is set (has been asigned a value) and false otherwise */
+    /** Returns true if field name is set (has been asigned a value) and false otherwise */
-    public boolean isSetStatus() {
+    public boolean isSetName() {
-      return this.status != null;
+      return this.name != null;
+    }
-    public void setStatusIsSet(boolean value) {
+    public void setNameIsSet(boolean value) {
       if (!value) {
-        this.status = null;
+        this.name = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case STATUS:
+      case NAME:
         if (value == null) {
-          unsetStatus();
+          unsetName();
         } else {
-          setStatus((CartStatus)value);
+          setName((String)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case STATUS:
+      case NAME:
-        return getStatus();
+        return getName();
+      }
       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 STATUS:
+      case NAME:
-        return isSetStatus();
+        return isSetName();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCartsByStatus_args)
+      if (that instanceof getAffiliateByName_args)
-        return this.equals((getCartsByStatus_args)that);
+        return this.equals((getAffiliateByName_args)that);
       return false;
+    }
-    public boolean equals(getCartsByStatus_args that) {
+    public boolean equals(getAffiliateByName_args that) {
       if (that == null)
         return false;
-      boolean this_present_status = true && this.isSetStatus();
+      boolean this_present_name = true && this.isSetName();
-      boolean that_present_status = true && that.isSetStatus();
+      boolean that_present_name = true && that.isSetName();
-      if (this_present_status || that_present_status) {
+      if (this_present_name || that_present_name) {
-        if (!(this_present_status && that_present_status))
+        if (!(this_present_name && that_present_name))
           return false;
-        if (!this.status.equals(that.status))
+        if (!this.name.equals(that.name))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCartsByStatus_args other) {
+    public int compareTo(getAffiliateByName_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCartsByStatus_args typedOther = (getCartsByStatus_args)other;
+      getAffiliateByName_args typedOther = (getAffiliateByName_args)other;
-      lastComparison = Boolean.valueOf(isSetStatus()).compareTo(isSetStatus());
+      lastComparison = Boolean.valueOf(isSetName()).compareTo(isSetName());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(status, typedOther.status);
+      lastComparison = TBaseHelper.compareTo(name, typedOther.name);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case STATUS:
+            case NAME:
-              if (field.type == TType.I32) {
+              if (field.type == TType.STRING) {
-                this.status = CartStatus.findByValue(iprot.readI32());
+                this.name = iprot.readString();
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
-      if (this.status != null) {
+      if (this.name != null) {
-        oprot.writeFieldBegin(STATUS_FIELD_DESC);
+        oprot.writeFieldBegin(NAME_FIELD_DESC);
-        oprot.writeI32(this.status.getValue());
+        oprot.writeString(this.name);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCartsByStatus_args(");
+      StringBuilder sb = new StringBuilder("getAffiliateByName_args(");
       boolean first = true;
-      sb.append("status:");
+      sb.append("name:");
-      if (this.status == null) {
+      if (this.name == null) {
         sb.append("null");
       } else {
-        String status_name = status.name();
+        sb.append(this.name);
+      }
-        if (status_name != null) {
+      first = false;
-          sb.append(status_name);
+      sb.append(")");
-          sb.append(" (");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getAffiliateByName_result implements TBase<getAffiliateByName_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAffiliateByName_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getAffiliateByName_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private Affiliate success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new StructMetaData(TType.STRUCT, Affiliate.class)));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getAffiliateByName_result.class, metaDataMap);
+    }
+    public getAffiliateByName_result() {
+    }
+    public getAffiliateByName_result(
+      Affiliate success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAffiliateByName_result(getAffiliateByName_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new Affiliate(other.success);
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public getAffiliateByName_result deepCopy() {
+      return new getAffiliateByName_result(this);
+    }
+    @Deprecated
+    public getAffiliateByName_result clone() {
+      return new getAffiliateByName_result(this);
+    }
+    public Affiliate getSuccess() {
-        sb.append(this.status);
+      return this.success;
+    }
+    public getAffiliateByName_result setSuccess(Affiliate success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public getAffiliateByName_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
-        if (status_name != null) {
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Affiliate)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
-          sb.append(")");
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 getAffiliateByName_result)
+        return this.equals((getAffiliateByName_result)that);
+      return false;
+    }
+    public boolean equals(getAffiliateByName_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getAffiliateByName_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getAffiliateByName_result typedOther = (getAffiliateByName_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 SUCCESS:
+              if (field.type == TType.STRUCT) {
+                this.success = new Affiliate();
+                this.success.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        this.success.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getAffiliateByName_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
+  public static class getAffiliatesByMasterAffiliate_args implements TBase<getAffiliatesByMasterAffiliate_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAffiliatesByMasterAffiliate_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getAffiliatesByMasterAffiliate_args");
+    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);
+    private long id;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      ID((short)1, "id");
+      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 __ID_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.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getAffiliatesByMasterAffiliate_args.class, metaDataMap);
+    }
+    public getAffiliatesByMasterAffiliate_args() {
+    }
+    public getAffiliatesByMasterAffiliate_args(
+      long id)
+    {
+      this();
+      this.id = id;
+      setIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAffiliatesByMasterAffiliate_args(getAffiliatesByMasterAffiliate_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.id = other.id;
+    }
+    public getAffiliatesByMasterAffiliate_args deepCopy() {
+      return new getAffiliatesByMasterAffiliate_args(this);
+    }
+    @Deprecated
+    public getAffiliatesByMasterAffiliate_args clone() {
+      return new getAffiliatesByMasterAffiliate_args(this);
+    }
+    public long getId() {
+      return this.id;
+    }
+    public getAffiliatesByMasterAffiliate_args setId(long id) {
+      this.id = id;
+      setIdIsSet(true);
+      return this;
+    }
+    public void unsetId() {
+      __isset_bit_vector.clear(__ID_ISSET_ID);
+    }
+    /** Returns true if field id is set (has been asigned a value) and false otherwise */
+    public boolean isSetId() {
+      return __isset_bit_vector.get(__ID_ISSET_ID);
+    }
+    public void setIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ID:
+        if (value == null) {
+          unsetId();
+        } else {
+          setId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ID:
+        return new Long(getId());
+      }
+      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 ID:
+        return isSetId();
+      }
+      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 getAffiliatesByMasterAffiliate_args)
+        return this.equals((getAffiliatesByMasterAffiliate_args)that);
+      return false;
+    }
+    public boolean equals(getAffiliatesByMasterAffiliate_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_id = true;
+      boolean that_present_id = true;
+      if (this_present_id || that_present_id) {
+        if (!(this_present_id && that_present_id))
+          return false;
+        if (this.id != that.id)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getAffiliatesByMasterAffiliate_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getAffiliatesByMasterAffiliate_args typedOther = (getAffiliatesByMasterAffiliate_args)other;
+      lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(id, typedOther.id);
+      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 ID:
+              if (field.type == TType.I64) {
+                this.id = iprot.readI64();
+                setIdIsSet(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(ID_FIELD_DESC);
+      oprot.writeI64(this.id);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getAffiliatesByMasterAffiliate_args(");
+      boolean first = true;
+      sb.append("id:");
+      sb.append(this.id);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
-  public static class getCartsByStatus_result implements TBase<getCartsByStatus_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByStatus_result>   {
+  public static class getAffiliatesByMasterAffiliate_result implements TBase<getAffiliatesByMasterAffiliate_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAffiliatesByMasterAffiliate_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCartsByStatus_result");
+    private static final TStruct STRUCT_DESC = new TStruct("getAffiliatesByMasterAffiliate_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
-    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
-    private List<Cart> success;
+    private List<Affiliate> success;
-    private ShoppingCartException scx;
+    private UserTrackerException utx;
     /** 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"),
-      SCX((short)1, "scx");
+      UTX((short)1, "utx");
       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
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
           new ListMetaData(TType.LIST,
-              new StructMetaData(TType.STRUCT, Cart.class))));
+              new StructMetaData(TType.STRUCT, Affiliate.class))));
-      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCartsByStatus_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getAffiliatesByMasterAffiliate_result.class, metaDataMap);
+    }
-    public getCartsByStatus_result() {
+    public getAffiliatesByMasterAffiliate_result() {
+    }
-    public getCartsByStatus_result(
+    public getAffiliatesByMasterAffiliate_result(
-      List<Cart> success,
+      List<Affiliate> success,
-      ShoppingCartException scx)
+      UserTrackerException utx)
+    {
       this();
       this.success = success;
-      this.scx = scx;
+      this.utx = utx;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCartsByStatus_result(getCartsByStatus_result other) {
+    public getAffiliatesByMasterAffiliate_result(getAffiliatesByMasterAffiliate_result other) {
       if (other.isSetSuccess()) {
-        List<Cart> __this__success = new ArrayList<Cart>();
+        List<Affiliate> __this__success = new ArrayList<Affiliate>();
-        for (Cart other_element : other.success) {
+        for (Affiliate other_element : other.success) {
-          __this__success.add(new Cart(other_element));
+          __this__success.add(new Affiliate(other_element));
+        }
         this.success = __this__success;
+      }
-      if (other.isSetScx()) {
+      if (other.isSetUtx()) {
-        this.scx = new ShoppingCartException(other.scx);
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
-    public getCartsByStatus_result deepCopy() {
+    public getAffiliatesByMasterAffiliate_result deepCopy() {
-      return new getCartsByStatus_result(this);
+      return new getAffiliatesByMasterAffiliate_result(this);
+    }
     @Deprecated
-    public getCartsByStatus_result clone() {
+    public getAffiliatesByMasterAffiliate_result clone() {
-      return new getCartsByStatus_result(this);
+      return new getAffiliatesByMasterAffiliate_result(this);
+    }
     public int getSuccessSize() {
       return (this.success == null) ? 0 : this.success.size();
+    }
-    public java.util.Iterator<Cart> getSuccessIterator() {
+    public java.util.Iterator<Affiliate> getSuccessIterator() {
       return (this.success == null) ? null : this.success.iterator();
+    }
-    public void addToSuccess(Cart elem) {
+    public void addToSuccess(Affiliate elem) {
       if (this.success == null) {
-        this.success = new ArrayList<Cart>();
+        this.success = new ArrayList<Affiliate>();
+      }
       this.success.add(elem);
+    }
-    public List<Cart> getSuccess() {
+    public List<Affiliate> getSuccess() {
       return this.success;
+    }
-    public getCartsByStatus_result setSuccess(List<Cart> success) {
+    public getAffiliatesByMasterAffiliate_result setSuccess(List<Affiliate> success) {
       this.success = success;
       return this;
+    }
     public void unsetSuccess() {
       if (!value) {
         this.success = null;
+      }
+    }
-    public ShoppingCartException getScx() {
+    public UserTrackerException getUtx() {
-      return this.scx;
+      return this.utx;
+    }
-    public getCartsByStatus_result setScx(ShoppingCartException scx) {
+    public getAffiliatesByMasterAffiliate_result setUtx(UserTrackerException utx) {
-      this.scx = scx;
+      this.utx = utx;
       return this;
+    }
-    public void unsetScx() {
+    public void unsetUtx() {
-      this.scx = null;
+      this.utx = null;
+    }
-    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
-    public boolean isSetScx() {
+    public boolean isSetUtx() {
-      return this.scx != null;
+      return this.utx != null;
+    }
-    public void setScxIsSet(boolean value) {
+    public void setUtxIsSet(boolean value) {
       if (!value) {
-        this.scx = null;
+        this.utx = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((List<Cart>)value);
+          setSuccess((List<Affiliate>)value);
+        }
         break;
-      case SCX:
+      case UTX:
         if (value == null) {
-          unsetScx();
+          unsetUtx();
         } else {
-          setScx((ShoppingCartException)value);
+          setUtx((UserTrackerException)value);
+        }
         break;
+      }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
-      case SCX:
+      case UTX:
-        return getScx();
+        return getUtx();
+      }
       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 SUCCESS:
         return isSetSuccess();
-      case SCX:
+      case UTX:
-        return isSetScx();
+        return isSetUtx();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCartsByStatus_result)
+      if (that instanceof getAffiliatesByMasterAffiliate_result)
-        return this.equals((getCartsByStatus_result)that);
+        return this.equals((getAffiliatesByMasterAffiliate_result)that);
       return false;
+    }
-    public boolean equals(getCartsByStatus_result that) {
+    public boolean equals(getAffiliatesByMasterAffiliate_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
           return false;
         if (!this.success.equals(that.success))
           return false;
+      }
-      boolean this_present_scx = true && this.isSetScx();
+      boolean this_present_utx = true && this.isSetUtx();
-      boolean that_present_scx = true && that.isSetScx();
+      boolean that_present_utx = true && that.isSetUtx();
-      if (this_present_scx || that_present_scx) {
+      if (this_present_utx || that_present_utx) {
-        if (!(this_present_scx && that_present_scx))
+        if (!(this_present_utx && that_present_utx))
           return false;
-        if (!this.scx.equals(that.scx))
+        if (!this.utx.equals(that.utx))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCartsByStatus_result other) {
+    public int compareTo(getAffiliatesByMasterAffiliate_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCartsByStatus_result typedOther = (getCartsByStatus_result)other;
+      getAffiliatesByMasterAffiliate_result typedOther = (getAffiliatesByMasterAffiliate_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(isSetScx()).compareTo(isSetScx());
+      lastComparison = Boolean.valueOf(isSetUtx()).compareTo(isSetUtx());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list32 = iprot.readListBegin();
+                  TList _list28 = iprot.readListBegin();
-                  this.success = new ArrayList<Cart>(_list32.size);
+                  this.success = new ArrayList<Affiliate>(_list28.size);
-                  for (int _i33 = 0; _i33 < _list32.size; ++_i33)
+                  for (int _i29 = 0; _i29 < _list28.size; ++_i29)
+                  {
-                    Cart _elem34;
+                    Affiliate _elem30;
-                    _elem34 = new Cart();
+                    _elem30 = new Affiliate();
-                    _elem34.read(iprot);
+                    _elem30.read(iprot);
-                    this.success.add(_elem34);
+                    this.success.add(_elem30);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case SCX:
+            case UTX:
               if (field.type == TType.STRUCT) {
-                this.scx = new ShoppingCartException();
+                this.utx = new UserTrackerException();
-                this.scx.read(iprot);
+                this.utx.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Cart _iter35 : this.success)
+          for (Affiliate _iter31 : this.success)
+          {
-            _iter35.write(oprot);
+            _iter31.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
-      } else if (this.isSetScx()) {
+      } else if (this.isSetUtx()) {
-        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
-        this.scx.write(oprot);
+        this.utx.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCartsByStatus_result(");
+      StringBuilder sb = new StringBuilder("getAffiliatesByMasterAffiliate_result(");
       boolean first = true;
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
         sb.append(this.success);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("scx:");
+      sb.append("utx:");
-      if (this.scx == null) {
+      if (this.utx == null) {
         sb.append("null");
       } else {
-        sb.append(this.scx);
+        sb.append(this.utx);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCartsByTime_args implements TBase<getCartsByTime_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByTime_args>   {
+  public static class createTracker_args implements TBase<createTracker_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTracker_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCartsByTime_args");
+    private static final TStruct STRUCT_DESC = new TStruct("createTracker_args");
-    private static final TField FROM_TIME_FIELD_DESC = new TField("from_time", TType.I64, (short)1);
+    private static final TField AFFILIATE_ID_FIELD_DESC = new TField("affiliateId", TType.I64, (short)1);
-    private static final TField TO_TIME_FIELD_DESC = new TField("to_time", TType.I64, (short)2);
-    private static final TField STATUS_FIELD_DESC = new TField("status", TType.I32, (short)3);
-    private long from_time;
+    private long affiliateId;
-    private long to_time;
-    private CartStatus status;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
-      FROM_TIME((short)1, "from_time"),
+      AFFILIATE_ID((short)1, "affiliateId");
-      TO_TIME((short)2, "to_time"),
-      /**
-       *
-       * @see CartStatus
-       */
-      STATUS((short)3, "status");
       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 __FROM_TIME_ISSET_ID = 0;
+    private static final int __AFFILIATEID_ISSET_ID = 0;
-    private static final int __TO_TIME_ISSET_ID = 1;
-    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_TIME, new FieldMetaData("from_time", TFieldRequirementType.DEFAULT,
+      put(_Fields.AFFILIATE_ID, new FieldMetaData("affiliateId", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.I64)));
-      put(_Fields.TO_TIME, new FieldMetaData("to_time", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
-      put(_Fields.STATUS, new FieldMetaData("status", TFieldRequirementType.DEFAULT,
-          new EnumMetaData(TType.ENUM, CartStatus.class)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCartsByTime_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(createTracker_args.class, metaDataMap);
+    }
-    public getCartsByTime_args() {
+    public createTracker_args() {
+    }
-    public getCartsByTime_args(
+    public createTracker_args(
-      long from_time,
+      long affiliateId)
-      long to_time,
-      CartStatus status)
+    {
       this();
-      this.from_time = from_time;
+      this.affiliateId = affiliateId;
-      setFrom_timeIsSet(true);
-      this.to_time = to_time;
-      setTo_timeIsSet(true);
+      setAffiliateIdIsSet(true);
-      this.status = status;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCartsByTime_args(getCartsByTime_args other) {
+    public createTracker_args(createTracker_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
-      this.from_time = other.from_time;
+      this.affiliateId = other.affiliateId;
-      this.to_time = other.to_time;
-      if (other.isSetStatus()) {
-        this.status = other.status;
-      }
+    }
-    public getCartsByTime_args deepCopy() {
+    public createTracker_args deepCopy() {
-      return new getCartsByTime_args(this);
+      return new createTracker_args(this);
+    }
     @Deprecated
-    public getCartsByTime_args clone() {
+    public createTracker_args clone() {
-      return new getCartsByTime_args(this);
+      return new createTracker_args(this);
+    }
-    public long getFrom_time() {
+    public long getAffiliateId() {
-      return this.from_time;
+      return this.affiliateId;
+    }
-    public getCartsByTime_args setFrom_time(long from_time) {
+    public createTracker_args setAffiliateId(long affiliateId) {
-      this.from_time = from_time;
+      this.affiliateId = affiliateId;
-      setFrom_timeIsSet(true);
+      setAffiliateIdIsSet(true);
       return this;
+    }
-    public void unsetFrom_time() {
+    public void unsetAffiliateId() {
-      __isset_bit_vector.clear(__FROM_TIME_ISSET_ID);
+      __isset_bit_vector.clear(__AFFILIATEID_ISSET_ID);
+    }
-    /** Returns true if field from_time is set (has been asigned a value) and false otherwise */
+    /** Returns true if field affiliateId is set (has been asigned a value) and false otherwise */
-    public boolean isSetFrom_time() {
+    public boolean isSetAffiliateId() {
-      return __isset_bit_vector.get(__FROM_TIME_ISSET_ID);
+      return __isset_bit_vector.get(__AFFILIATEID_ISSET_ID);
+    }
-    public void setFrom_timeIsSet(boolean value) {
+    public void setAffiliateIdIsSet(boolean value) {
-      __isset_bit_vector.set(__FROM_TIME_ISSET_ID, value);
+      __isset_bit_vector.set(__AFFILIATEID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case AFFILIATE_ID:
-    public long getTo_time() {
+        if (value == null) {
-      return this.to_time;
+          unsetAffiliateId();
+        } else {
+          setAffiliateId((Long)value);
+        }
+        break;
+      }
+    }
-    public getCartsByTime_args setTo_time(long to_time) {
+    public void setFieldValue(int fieldID, Object value) {
-      this.to_time = to_time;
-      setTo_timeIsSet(true);
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
-      return this;
+    }
-    public void unsetTo_time() {
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case AFFILIATE_ID:
-      __isset_bit_vector.clear(__TO_TIME_ISSET_ID);
+        return new Long(getAffiliateId());
+      }
+      throw new IllegalStateException();
+    }
-    /** Returns true if field to_time is set (has been asigned a value) and false otherwise */
-    public boolean isSetTo_time() {
+    public Object getFieldValue(int fieldId) {
-      return __isset_bit_vector.get(__TO_TIME_ISSET_ID);
+      return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+    }
+    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
-    public void setTo_timeIsSet(boolean value) {
+    public boolean isSet(_Fields field) {
+      switch (field) {
+      case AFFILIATE_ID:
+        return isSetAffiliateId();
+      }
-      __isset_bit_vector.set(__TO_TIME_ISSET_ID, value);
+      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 createTracker_args)
+        return this.equals((createTracker_args)that);
+      return false;
+    }
+    public boolean equals(createTracker_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_affiliateId = true;
+      boolean that_present_affiliateId = true;
+      if (this_present_affiliateId || that_present_affiliateId) {
+        if (!(this_present_affiliateId && that_present_affiliateId))
+          return false;
+        if (this.affiliateId != that.affiliateId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(createTracker_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createTracker_args typedOther = (createTracker_args)other;
+      lastComparison = Boolean.valueOf(isSetAffiliateId()).compareTo(isSetAffiliateId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(affiliateId, typedOther.affiliateId);
+      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 AFFILIATE_ID:
+              if (field.type == TType.I64) {
+                this.affiliateId = iprot.readI64();
+                setAffiliateIdIsSet(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(AFFILIATE_ID_FIELD_DESC);
+      oprot.writeI64(this.affiliateId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("createTracker_args(");
+      boolean first = true;
+      sb.append("affiliateId:");
+      sb.append(this.affiliateId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class createTracker_result implements TBase<createTracker_result._Fields>, java.io.Serializable, Cloneable, Comparable<createTracker_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("createTracker_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private Tracker success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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!");
-     * @see CartStatus
+        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 CartStatus getStatus() {
+      public String getFieldName() {
-      return this.status;
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new StructMetaData(TType.STRUCT, Tracker.class)));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(createTracker_result.class, metaDataMap);
+    }
+    public createTracker_result() {
+    }
+    public createTracker_result(
+      Tracker success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
     /**
-     *
-     * @see CartStatus
+     * Performs a deep copy on <i>other</i>.
      */
+    public createTracker_result(createTracker_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new Tracker(other.success);
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public createTracker_result deepCopy() {
+      return new createTracker_result(this);
+    }
+    @Deprecated
+    public createTracker_result clone() {
+      return new createTracker_result(this);
+    }
+    public Tracker getSuccess() {
+      return this.success;
+    }
-    public getCartsByTime_args setStatus(CartStatus status) {
+    public createTracker_result setSuccess(Tracker success) {
-      this.status = status;
+      this.success = success;
       return this;
+    }
-    public void unsetStatus() {
+    public void unsetSuccess() {
-      this.status = null;
+      this.success = null;
+    }
-    /** Returns true if field status is set (has been asigned a value) and false otherwise */
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
-    public boolean isSetStatus() {
+    public boolean isSetSuccess() {
-      return this.status != null;
+      return this.success != null;
+    }
-    public void setStatusIsSet(boolean value) {
+    public void setSuccessIsSet(boolean value) {
       if (!value) {
-        this.status = null;
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public createTracker_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case FROM_TIME:
-        if (value == null) {
-          unsetFrom_time();
-        } else {
-          setFrom_time((Long)value);
-        }
-        break;
-      case TO_TIME:
+      case SUCCESS:
         if (value == null) {
-          unsetTo_time();
+          unsetSuccess();
         } else {
-          setTo_time((Long)value);
+          setSuccess((Tracker)value);
+        }
         break;
-      case STATUS:
+      case UTX:
         if (value == null) {
-          unsetStatus();
+          unsetUtx();
         } else {
-          setStatus((CartStatus)value);
+          setUtx((UserTrackerException)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case FROM_TIME:
-        return new Long(getFrom_time());
-      case TO_TIME:
+      case SUCCESS:
-        return new Long(getTo_time());
+        return getSuccess();
-      case STATUS:
+      case UTX:
-        return getStatus();
+        return getUtx();
+      }
       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_TIME:
-        return isSetFrom_time();
-      case TO_TIME:
+      case SUCCESS:
-        return isSetTo_time();
+        return isSetSuccess();
-      case STATUS:
+      case UTX:
-        return isSetStatus();
+        return isSetUtx();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCartsByTime_args)
+      if (that instanceof createTracker_result)
-        return this.equals((getCartsByTime_args)that);
+        return this.equals((createTracker_result)that);
       return false;
+    }
-    public boolean equals(getCartsByTime_args that) {
+    public boolean equals(createTracker_result that) {
       if (that == null)
         return false;
-      boolean this_present_from_time = true;
+      boolean this_present_success = true && this.isSetSuccess();
-      boolean that_present_from_time = true;
+      boolean that_present_success = true && that.isSetSuccess();
-      if (this_present_from_time || that_present_from_time) {
-        if (!(this_present_from_time && that_present_from_time))
-          return false;
-        if (this.from_time != that.from_time)
-          return false;
-      }
-      boolean this_present_to_time = true;
-      boolean that_present_to_time = true;
-      if (this_present_to_time || that_present_to_time) {
+      if (this_present_success || that_present_success) {
-        if (!(this_present_to_time && that_present_to_time))
+        if (!(this_present_success && that_present_success))
           return false;
-        if (this.to_time != that.to_time)
+        if (!this.success.equals(that.success))
           return false;
+      }
-      boolean this_present_status = true && this.isSetStatus();
+      boolean this_present_utx = true && this.isSetUtx();
-      boolean that_present_status = true && that.isSetStatus();
+      boolean that_present_utx = true && that.isSetUtx();
-      if (this_present_status || that_present_status) {
+      if (this_present_utx || that_present_utx) {
-        if (!(this_present_status && that_present_status))
+        if (!(this_present_utx && that_present_utx))
           return false;
-        if (!this.status.equals(that.status))
+        if (!this.utx.equals(that.utx))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCartsByTime_args other) {
+    public int compareTo(createTracker_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCartsByTime_args typedOther = (getCartsByTime_args)other;
+      createTracker_result typedOther = (createTracker_result)other;
-      lastComparison = Boolean.valueOf(isSetFrom_time()).compareTo(isSetFrom_time());
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(from_time, typedOther.from_time);
+      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = Boolean.valueOf(isSetTo_time()).compareTo(isSetTo_time());
+      lastComparison = Boolean.valueOf(isSetUtx()).compareTo(isSetUtx());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(to_time, typedOther.to_time);
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
       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 SUCCESS:
+              if (field.type == TType.STRUCT) {
+                this.success = new Tracker();
+                this.success.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        this.success.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("createTracker_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackerById_args implements TBase<getTrackerById_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackerById_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackerById_args");
+    private static final TField TRACKER_ID_FIELD_DESC = new TField("trackerId", TType.I64, (short)1);
+    private long trackerId;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      TRACKER_ID((short)1, "trackerId");
+      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 __TRACKERID_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.TRACKER_ID, new FieldMetaData("trackerId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackerById_args.class, metaDataMap);
+    }
+    public getTrackerById_args() {
+    }
+    public getTrackerById_args(
+      long trackerId)
+    {
+      this();
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackerById_args(getTrackerById_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.trackerId = other.trackerId;
+    }
+    public getTrackerById_args deepCopy() {
+      return new getTrackerById_args(this);
+    }
+    @Deprecated
+    public getTrackerById_args clone() {
+      return new getTrackerById_args(this);
+    }
+    public long getTrackerId() {
+      return this.trackerId;
+    }
+    public getTrackerById_args setTrackerId(long trackerId) {
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+      return this;
+    }
+    public void unsetTrackerId() {
+      __isset_bit_vector.clear(__TRACKERID_ISSET_ID);
+    }
+    /** Returns true if field trackerId is set (has been asigned a value) and false otherwise */
+    public boolean isSetTrackerId() {
+      return __isset_bit_vector.get(__TRACKERID_ISSET_ID);
+    }
+    public void setTrackerIdIsSet(boolean value) {
+      __isset_bit_vector.set(__TRACKERID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case TRACKER_ID:
+        if (value == null) {
+          unsetTrackerId();
+        } else {
+          setTrackerId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case TRACKER_ID:
+        return new Long(getTrackerId());
+      }
+      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 TRACKER_ID:
+        return isSetTrackerId();
+      }
+      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 getTrackerById_args)
+        return this.equals((getTrackerById_args)that);
+      return false;
+    }
+    public boolean equals(getTrackerById_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_trackerId = true;
+      boolean that_present_trackerId = true;
+      if (this_present_trackerId || that_present_trackerId) {
+        if (!(this_present_trackerId && that_present_trackerId))
+          return false;
+        if (this.trackerId != that.trackerId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackerById_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackerById_args typedOther = (getTrackerById_args)other;
-      lastComparison = Boolean.valueOf(isSetStatus()).compareTo(isSetStatus());
+      lastComparison = Boolean.valueOf(isSetTrackerId()).compareTo(isSetTrackerId());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(status, typedOther.status);
+      lastComparison = TBaseHelper.compareTo(trackerId, typedOther.trackerId);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case FROM_TIME:
+            case TRACKER_ID:
               if (field.type == TType.I64) {
-                this.from_time = iprot.readI64();
+                this.trackerId = iprot.readI64();
-                setFrom_timeIsSet(true);
+                setTrackerIdIsSet(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(TRACKER_ID_FIELD_DESC);
+      oprot.writeI64(this.trackerId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackerById_args(");
+      boolean first = true;
+      sb.append("trackerId:");
+      sb.append(this.trackerId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackerById_result implements TBase<getTrackerById_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackerById_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackerById_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private Tracker success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new StructMetaData(TType.STRUCT, Tracker.class)));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackerById_result.class, metaDataMap);
+    }
+    public getTrackerById_result() {
+    }
+    public getTrackerById_result(
+      Tracker success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackerById_result(getTrackerById_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new Tracker(other.success);
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public getTrackerById_result deepCopy() {
+      return new getTrackerById_result(this);
+    }
+    @Deprecated
+    public getTrackerById_result clone() {
+      return new getTrackerById_result(this);
+    }
+    public Tracker getSuccess() {
+      return this.success;
+    }
+    public getTrackerById_result setSuccess(Tracker success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public getTrackerById_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Tracker)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 getTrackerById_result)
+        return this.equals((getTrackerById_result)that);
+      return false;
+    }
+    public boolean equals(getTrackerById_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackerById_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackerById_result typedOther = (getTrackerById_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 TO_TIME:
+            case SUCCESS:
-              if (field.type == TType.I64) {
+              if (field.type == TType.STRUCT) {
-                this.to_time = iprot.readI64();
+                this.success = new Tracker();
-                setTo_timeIsSet(true);
+                this.success.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case STATUS:
+            case UTX:
-              if (field.type == TType.I32) {
+              if (field.type == TType.STRUCT) {
-                this.status = CartStatus.findByValue(iprot.readI32());
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
       iprot.readStructEnd();
       validate();
+    }
     public void write(TProtocol oprot) throws TException {
-      validate();
       oprot.writeStructBegin(STRUCT_DESC);
-      oprot.writeFieldBegin(FROM_TIME_FIELD_DESC);
-      oprot.writeI64(this.from_time);
-      oprot.writeFieldEnd();
+      if (this.isSetSuccess()) {
-      oprot.writeFieldBegin(TO_TIME_FIELD_DESC);
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-      oprot.writeI64(this.to_time);
+        this.success.write(oprot);
-      oprot.writeFieldEnd();
+        oprot.writeFieldEnd();
-      if (this.status != null) {
+      } else if (this.isSetUtx()) {
-        oprot.writeFieldBegin(STATUS_FIELD_DESC);
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
-        oprot.writeI32(this.status.getValue());
+        this.utx.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCartsByTime_args(");
+      StringBuilder sb = new StringBuilder("getTrackerById_result(");
       boolean first = true;
-      sb.append("from_time:");
+      sb.append("success:");
-      sb.append(this.from_time);
-      first = false;
+      if (this.success == null) {
-      if (!first) sb.append(", ");
+        sb.append("null");
-      sb.append("to_time:");
+      } else {
-      sb.append(this.to_time);
+        sb.append(this.success);
+      }
       first = false;
       if (!first) sb.append(", ");
-      sb.append("status:");
+      sb.append("utx:");
-      if (this.status == null) {
+      if (this.utx == null) {
         sb.append("null");
       } else {
-        String status_name = status.name();
+        sb.append(this.utx);
+      }
-        if (status_name != null) {
+      first = false;
-          sb.append(status_name);
+      sb.append(")");
-          sb.append(" (");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackersByAffiliate_args implements TBase<getTrackersByAffiliate_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackersByAffiliate_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackersByAffiliate_args");
+    private static final TField AFFILIATE_ID_FIELD_DESC = new TField("affiliateId", TType.I64, (short)1);
+    private long affiliateId;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      AFFILIATE_ID((short)1, "affiliateId");
+      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 __AFFILIATEID_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.AFFILIATE_ID, new FieldMetaData("affiliateId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackersByAffiliate_args.class, metaDataMap);
+    }
+    public getTrackersByAffiliate_args() {
+    }
+    public getTrackersByAffiliate_args(
+      long affiliateId)
+    {
+      this();
+      this.affiliateId = affiliateId;
+      setAffiliateIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackersByAffiliate_args(getTrackersByAffiliate_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.affiliateId = other.affiliateId;
+    }
+    public getTrackersByAffiliate_args deepCopy() {
+      return new getTrackersByAffiliate_args(this);
+    }
+    @Deprecated
+    public getTrackersByAffiliate_args clone() {
+      return new getTrackersByAffiliate_args(this);
+    }
+    public long getAffiliateId() {
+      return this.affiliateId;
+    }
+    public getTrackersByAffiliate_args setAffiliateId(long affiliateId) {
+      this.affiliateId = affiliateId;
-        sb.append(this.status);
+      setAffiliateIdIsSet(true);
+      return this;
+    }
+    public void unsetAffiliateId() {
+      __isset_bit_vector.clear(__AFFILIATEID_ISSET_ID);
+    }
+    /** Returns true if field affiliateId is set (has been asigned a value) and false otherwise */
+    public boolean isSetAffiliateId() {
+      return __isset_bit_vector.get(__AFFILIATEID_ISSET_ID);
+    }
+    public void setAffiliateIdIsSet(boolean value) {
+      __isset_bit_vector.set(__AFFILIATEID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case AFFILIATE_ID:
-        if (status_name != null) {
+        if (value == null) {
+          unsetAffiliateId();
+        } else {
+          setAffiliateId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case AFFILIATE_ID:
+        return new Long(getAffiliateId());
+      }
+      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 AFFILIATE_ID:
+        return isSetAffiliateId();
+      }
+      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 getTrackersByAffiliate_args)
+        return this.equals((getTrackersByAffiliate_args)that);
+      return false;
+    }
+    public boolean equals(getTrackersByAffiliate_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_affiliateId = true;
+      boolean that_present_affiliateId = true;
+      if (this_present_affiliateId || that_present_affiliateId) {
+        if (!(this_present_affiliateId && that_present_affiliateId))
+          return false;
+        if (this.affiliateId != that.affiliateId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackersByAffiliate_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackersByAffiliate_args typedOther = (getTrackersByAffiliate_args)other;
+      lastComparison = Boolean.valueOf(isSetAffiliateId()).compareTo(isSetAffiliateId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(affiliateId, typedOther.affiliateId);
+      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 AFFILIATE_ID:
+              if (field.type == TType.I64) {
+                this.affiliateId = iprot.readI64();
+                setAffiliateIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
-          sb.append(")");
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(AFFILIATE_ID_FIELD_DESC);
+      oprot.writeI64(this.affiliateId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackersByAffiliate_args(");
+      boolean first = true;
+      sb.append("affiliateId:");
+      sb.append(this.affiliateId);
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class getCartsByTime_result implements TBase<getCartsByTime_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByTime_result>   {
+  public static class getTrackersByAffiliate_result implements TBase<getTrackersByAffiliate_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackersByAffiliate_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCartsByTime_result");
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackersByAffiliate_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
-    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
-    private List<Cart> success;
+    private List<Tracker> success;
-    private ShoppingCartException scx;
+    private UserTrackerException utx;
     /** 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"),
-      SCX((short)1, "scx");
+      UTX((short)1, "utx");
       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
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
           new ListMetaData(TType.LIST,
-              new StructMetaData(TType.STRUCT, Cart.class))));
+              new StructMetaData(TType.STRUCT, Tracker.class))));
-      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRUCT)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCartsByTime_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getTrackersByAffiliate_result.class, metaDataMap);
+    }
-    public getCartsByTime_result() {
+    public getTrackersByAffiliate_result() {
+    }
-    public getCartsByTime_result(
+    public getTrackersByAffiliate_result(
-      List<Cart> success,
+      List<Tracker> success,
-      ShoppingCartException scx)
+      UserTrackerException utx)
+    {
       this();
       this.success = success;
-      this.scx = scx;
+      this.utx = utx;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCartsByTime_result(getCartsByTime_result other) {
+    public getTrackersByAffiliate_result(getTrackersByAffiliate_result other) {
       if (other.isSetSuccess()) {
-        List<Cart> __this__success = new ArrayList<Cart>();
+        List<Tracker> __this__success = new ArrayList<Tracker>();
-        for (Cart other_element : other.success) {
+        for (Tracker other_element : other.success) {
-          __this__success.add(new Cart(other_element));
+          __this__success.add(new Tracker(other_element));
+        }
         this.success = __this__success;
+      }
-      if (other.isSetScx()) {
+      if (other.isSetUtx()) {
-        this.scx = new ShoppingCartException(other.scx);
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
-    public getCartsByTime_result deepCopy() {
+    public getTrackersByAffiliate_result deepCopy() {
-      return new getCartsByTime_result(this);
+      return new getTrackersByAffiliate_result(this);
+    }
     @Deprecated
-    public getCartsByTime_result clone() {
+    public getTrackersByAffiliate_result clone() {
-      return new getCartsByTime_result(this);
+      return new getTrackersByAffiliate_result(this);
+    }
     public int getSuccessSize() {
       return (this.success == null) ? 0 : this.success.size();
+    }
-    public java.util.Iterator<Cart> getSuccessIterator() {
+    public java.util.Iterator<Tracker> getSuccessIterator() {
       return (this.success == null) ? null : this.success.iterator();
+    }
-    public void addToSuccess(Cart elem) {
+    public void addToSuccess(Tracker elem) {
       if (this.success == null) {
-        this.success = new ArrayList<Cart>();
+        this.success = new ArrayList<Tracker>();
+      }
       this.success.add(elem);
+    }
-    public List<Cart> getSuccess() {
+    public List<Tracker> getSuccess() {
       return this.success;
+    }
-    public getCartsByTime_result setSuccess(List<Cart> success) {
+    public getTrackersByAffiliate_result setSuccess(List<Tracker> success) {
       this.success = success;
       return this;
+    }
     public void unsetSuccess() {
       if (!value) {
         this.success = null;
+      }
+    }
-    public ShoppingCartException getScx() {
+    public UserTrackerException getUtx() {
-      return this.scx;
+      return this.utx;
+    }
-    public getCartsByTime_result setScx(ShoppingCartException scx) {
+    public getTrackersByAffiliate_result setUtx(UserTrackerException utx) {
-      this.scx = scx;
+      this.utx = utx;
       return this;
+    }
-    public void unsetScx() {
+    public void unsetUtx() {
-      this.scx = null;
+      this.utx = null;
+    }
-    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
-    public boolean isSetScx() {
+    public boolean isSetUtx() {
-      return this.scx != null;
+      return this.utx != null;
+    }
-    public void setScxIsSet(boolean value) {
+    public void setUtxIsSet(boolean value) {
       if (!value) {
-        this.scx = null;
+        this.utx = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((List<Cart>)value);
+          setSuccess((List<Tracker>)value);
+        }
         break;
-      case SCX:
+      case UTX:
         if (value == null) {
-          unsetScx();
+          unsetUtx();
         } else {
-          setScx((ShoppingCartException)value);
+          setUtx((UserTrackerException)value);
+        }
         break;
+      }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case SUCCESS:
         return getSuccess();
-      case SCX:
+      case UTX:
-        return getScx();
+        return getUtx();
+      }
       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 SUCCESS:
         return isSetSuccess();
-      case SCX:
+      case UTX:
-        return isSetScx();
+        return isSetUtx();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCartsByTime_result)
+      if (that instanceof getTrackersByAffiliate_result)
-        return this.equals((getCartsByTime_result)that);
+        return this.equals((getTrackersByAffiliate_result)that);
       return false;
+    }
-    public boolean equals(getCartsByTime_result that) {
+    public boolean equals(getTrackersByAffiliate_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
           return false;
         if (!this.success.equals(that.success))
           return false;
+      }
-      boolean this_present_scx = true && this.isSetScx();
+      boolean this_present_utx = true && this.isSetUtx();
-      boolean that_present_scx = true && that.isSetScx();
+      boolean that_present_utx = true && that.isSetUtx();
-      if (this_present_scx || that_present_scx) {
+      if (this_present_utx || that_present_utx) {
-        if (!(this_present_scx && that_present_scx))
+        if (!(this_present_utx && that_present_utx))
           return false;
-        if (!this.scx.equals(that.scx))
+        if (!this.utx.equals(that.utx))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCartsByTime_result other) {
+    public int compareTo(getTrackersByAffiliate_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCartsByTime_result typedOther = (getCartsByTime_result)other;
+      getTrackersByAffiliate_result typedOther = (getTrackersByAffiliate_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(isSetScx()).compareTo(isSetScx());
+      lastComparison = Boolean.valueOf(isSetUtx()).compareTo(isSetUtx());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list36 = iprot.readListBegin();
+                  TList _list32 = iprot.readListBegin();
-                  this.success = new ArrayList<Cart>(_list36.size);
+                  this.success = new ArrayList<Tracker>(_list32.size);
-                  for (int _i37 = 0; _i37 < _list36.size; ++_i37)
+                  for (int _i33 = 0; _i33 < _list32.size; ++_i33)
+                  {
-                    Cart _elem38;
+                    Tracker _elem34;
-                    _elem38 = new Cart();
+                    _elem34 = new Tracker();
-                    _elem38.read(iprot);
+                    _elem34.read(iprot);
-                    this.success.add(_elem38);
+                    this.success.add(_elem34);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
-            case SCX:
+            case UTX:
               if (field.type == TType.STRUCT) {
-                this.scx = new ShoppingCartException();
+                this.utx = new UserTrackerException();
-                this.scx.read(iprot);
+                this.utx.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Cart _iter39 : this.success)
+          for (Tracker _iter35 : this.success)
+          {
+            _iter35.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackersByAffiliate_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class addTrackLog_args implements TBase<addTrackLog_args._Fields>, java.io.Serializable, Cloneable, Comparable<addTrackLog_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("addTrackLog_args");
+    private static final TField TRACKER_ID_FIELD_DESC = new TField("trackerId", TType.I64, (short)1);
+    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)2);
+    private static final TField EVENT_FIELD_DESC = new TField("event", TType.STRING, (short)3);
+    private static final TField URL_FIELD_DESC = new TField("url", TType.STRING, (short)4);
+    private static final TField DATA_FIELD_DESC = new TField("data", TType.STRING, (short)5);
+    private long trackerId;
+    private long userId;
+    private String event;
+    private String url;
+    private String data;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      TRACKER_ID((short)1, "trackerId"),
+      USER_ID((short)2, "userId"),
+      EVENT((short)3, "event"),
+      URL((short)4, "url"),
+      DATA((short)5, "data");
+      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 __TRACKERID_ISSET_ID = 0;
+    private static final int __USERID_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.TRACKER_ID, new FieldMetaData("trackerId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.EVENT, new FieldMetaData("event", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
+      put(_Fields.URL, new FieldMetaData("url", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
+      put(_Fields.DATA, new FieldMetaData("data", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(addTrackLog_args.class, metaDataMap);
+    }
+    public addTrackLog_args() {
+    }
+    public addTrackLog_args(
+      long trackerId,
+      long userId,
+      String event,
+      String url,
+      String data)
+    {
+      this();
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+      this.userId = userId;
+      setUserIdIsSet(true);
+      this.event = event;
+      this.url = url;
+      this.data = data;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public addTrackLog_args(addTrackLog_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.trackerId = other.trackerId;
+      this.userId = other.userId;
+      if (other.isSetEvent()) {
+        this.event = other.event;
+      }
+      if (other.isSetUrl()) {
+        this.url = other.url;
+      }
+      if (other.isSetData()) {
+        this.data = other.data;
+      }
+    }
+    public addTrackLog_args deepCopy() {
+      return new addTrackLog_args(this);
+    }
+    @Deprecated
+    public addTrackLog_args clone() {
+      return new addTrackLog_args(this);
+    }
+    public long getTrackerId() {
+      return this.trackerId;
+    }
+    public addTrackLog_args setTrackerId(long trackerId) {
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+      return this;
+    }
+    public void unsetTrackerId() {
+      __isset_bit_vector.clear(__TRACKERID_ISSET_ID);
+    }
+    /** Returns true if field trackerId is set (has been asigned a value) and false otherwise */
+    public boolean isSetTrackerId() {
+      return __isset_bit_vector.get(__TRACKERID_ISSET_ID);
+    }
+    public void setTrackerIdIsSet(boolean value) {
+      __isset_bit_vector.set(__TRACKERID_ISSET_ID, value);
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public addTrackLog_args setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+      return this;
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    public String getEvent() {
+      return this.event;
+    }
+    public addTrackLog_args setEvent(String event) {
+      this.event = event;
+      return this;
+    }
+    public void unsetEvent() {
+      this.event = null;
+    }
+    /** Returns true if field event is set (has been asigned a value) and false otherwise */
+    public boolean isSetEvent() {
+      return this.event != null;
+    }
+    public void setEventIsSet(boolean value) {
+      if (!value) {
+        this.event = null;
+      }
+    }
+    public String getUrl() {
+      return this.url;
+    }
+    public addTrackLog_args setUrl(String url) {
+      this.url = url;
+      return this;
+    }
+    public void unsetUrl() {
+      this.url = null;
+    }
+    /** Returns true if field url is set (has been asigned a value) and false otherwise */
+    public boolean isSetUrl() {
+      return this.url != null;
+    }
+    public void setUrlIsSet(boolean value) {
+      if (!value) {
+        this.url = null;
+      }
+    }
+    public String getData() {
+      return this.data;
+    }
+    public addTrackLog_args setData(String data) {
+      this.data = data;
+      return this;
+    }
+    public void unsetData() {
+      this.data = null;
+    }
+    /** Returns true if field data is set (has been asigned a value) and false otherwise */
+    public boolean isSetData() {
+      return this.data != null;
+    }
+    public void setDataIsSet(boolean value) {
+      if (!value) {
+        this.data = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case TRACKER_ID:
+        if (value == null) {
+          unsetTrackerId();
+        } else {
+          setTrackerId((Long)value);
+        }
+        break;
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      case EVENT:
+        if (value == null) {
+          unsetEvent();
+        } else {
+          setEvent((String)value);
+        }
+        break;
+      case URL:
+        if (value == null) {
+          unsetUrl();
+        } else {
+          setUrl((String)value);
+        }
+        break;
+      case DATA:
+        if (value == null) {
+          unsetData();
+        } else {
+          setData((String)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case TRACKER_ID:
+        return new Long(getTrackerId());
+      case USER_ID:
+        return new Long(getUserId());
+      case EVENT:
+        return getEvent();
+      case URL:
+        return getUrl();
+      case DATA:
+        return getData();
+      }
+      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 TRACKER_ID:
+        return isSetTrackerId();
+      case USER_ID:
+        return isSetUserId();
+      case EVENT:
+        return isSetEvent();
+      case URL:
+        return isSetUrl();
+      case DATA:
+        return isSetData();
+      }
+      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 addTrackLog_args)
+        return this.equals((addTrackLog_args)that);
+      return false;
+    }
+    public boolean equals(addTrackLog_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_trackerId = true;
+      boolean that_present_trackerId = true;
+      if (this_present_trackerId || that_present_trackerId) {
+        if (!(this_present_trackerId && that_present_trackerId))
+          return false;
+        if (this.trackerId != that.trackerId)
+          return false;
+      }
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      boolean this_present_event = true && this.isSetEvent();
+      boolean that_present_event = true && that.isSetEvent();
+      if (this_present_event || that_present_event) {
+        if (!(this_present_event && that_present_event))
+          return false;
+        if (!this.event.equals(that.event))
+          return false;
+      }
+      boolean this_present_url = true && this.isSetUrl();
+      boolean that_present_url = true && that.isSetUrl();
+      if (this_present_url || that_present_url) {
+        if (!(this_present_url && that_present_url))
+          return false;
+        if (!this.url.equals(that.url))
+          return false;
+      }
+      boolean this_present_data = true && this.isSetData();
+      boolean that_present_data = true && that.isSetData();
+      if (this_present_data || that_present_data) {
+        if (!(this_present_data && that_present_data))
+          return false;
+        if (!this.data.equals(that.data))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(addTrackLog_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      addTrackLog_args typedOther = (addTrackLog_args)other;
+      lastComparison = Boolean.valueOf(isSetTrackerId()).compareTo(isSetTrackerId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(trackerId, typedOther.trackerId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetEvent()).compareTo(isSetEvent());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(event, typedOther.event);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUrl()).compareTo(isSetUrl());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(url, typedOther.url);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetData()).compareTo(isSetData());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(data, typedOther.data);
+      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 TRACKER_ID:
+              if (field.type == TType.I64) {
+                this.trackerId = iprot.readI64();
+                setTrackerIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case USER_ID:
+              if (field.type == TType.I64) {
+                this.userId = iprot.readI64();
+                setUserIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case EVENT:
+              if (field.type == TType.STRING) {
+                this.event = iprot.readString();
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case URL:
+              if (field.type == TType.STRING) {
+                this.url = iprot.readString();
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case DATA:
+              if (field.type == TType.STRING) {
+                this.data = iprot.readString();
+              } 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(TRACKER_ID_FIELD_DESC);
+      oprot.writeI64(this.trackerId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      if (this.event != null) {
+        oprot.writeFieldBegin(EVENT_FIELD_DESC);
+        oprot.writeString(this.event);
+        oprot.writeFieldEnd();
+      }
+      if (this.url != null) {
+        oprot.writeFieldBegin(URL_FIELD_DESC);
+        oprot.writeString(this.url);
+        oprot.writeFieldEnd();
+      }
+      if (this.data != null) {
+        oprot.writeFieldBegin(DATA_FIELD_DESC);
+        oprot.writeString(this.data);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("addTrackLog_args(");
+      boolean first = true;
+      sb.append("trackerId:");
+      sb.append(this.trackerId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("event:");
+      if (this.event == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.event);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("url:");
+      if (this.url == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.url);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("data:");
+      if (this.data == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.data);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class addTrackLog_result implements TBase<addTrackLog_result._Fields>, java.io.Serializable, Cloneable, Comparable<addTrackLog_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("addTrackLog_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I64, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private long success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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 __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.I64)));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(addTrackLog_result.class, metaDataMap);
+    }
+    public addTrackLog_result() {
+    }
+    public addTrackLog_result(
+      long success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public addTrackLog_result(addTrackLog_result other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.success = other.success;
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public addTrackLog_result deepCopy() {
+      return new addTrackLog_result(this);
+    }
+    @Deprecated
+    public addTrackLog_result clone() {
+      return new addTrackLog_result(this);
+    }
+    public long getSuccess() {
+      return this.success;
+    }
+    public addTrackLog_result setSuccess(long 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 UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public addTrackLog_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Long)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)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 Long(getSuccess());
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 addTrackLog_result)
+        return this.equals((addTrackLog_result)that);
+      return false;
+    }
+    public boolean equals(addTrackLog_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_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(addTrackLog_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      addTrackLog_result typedOther = (addTrackLog_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 SUCCESS:
+              if (field.type == TType.I64) {
+                this.success = iprot.readI64();
+                setSuccessIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        oprot.writeI64(this.success);
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("addTrackLog_result(");
+      boolean first = true;
+      sb.append("success:");
+      sb.append(this.success);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogById_args implements TBase<getTrackLogById_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogById_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogById_args");
+    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);
+    private long id;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      ID((short)1, "id");
+      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 __ID_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.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogById_args.class, metaDataMap);
+    }
+    public getTrackLogById_args() {
+    }
+    public getTrackLogById_args(
+      long id)
+    {
+      this();
+      this.id = id;
+      setIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogById_args(getTrackLogById_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.id = other.id;
+    }
+    public getTrackLogById_args deepCopy() {
+      return new getTrackLogById_args(this);
+    }
+    @Deprecated
+    public getTrackLogById_args clone() {
+      return new getTrackLogById_args(this);
+    }
+    public long getId() {
+      return this.id;
+    }
+    public getTrackLogById_args setId(long id) {
+      this.id = id;
+      setIdIsSet(true);
+      return this;
+    }
+    public void unsetId() {
+      __isset_bit_vector.clear(__ID_ISSET_ID);
+    }
+    /** Returns true if field id is set (has been asigned a value) and false otherwise */
+    public boolean isSetId() {
+      return __isset_bit_vector.get(__ID_ISSET_ID);
+    }
+    public void setIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ID:
+        if (value == null) {
+          unsetId();
+        } else {
+          setId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ID:
+        return new Long(getId());
+      }
+      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 ID:
+        return isSetId();
+      }
+      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 getTrackLogById_args)
+        return this.equals((getTrackLogById_args)that);
+      return false;
+    }
+    public boolean equals(getTrackLogById_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_id = true;
+      boolean that_present_id = true;
+      if (this_present_id || that_present_id) {
+        if (!(this_present_id && that_present_id))
+          return false;
+        if (this.id != that.id)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogById_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogById_args typedOther = (getTrackLogById_args)other;
+      lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(id, typedOther.id);
+      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 ID:
+              if (field.type == TType.I64) {
+                this.id = iprot.readI64();
+                setIdIsSet(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(ID_FIELD_DESC);
+      oprot.writeI64(this.id);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogById_args(");
+      boolean first = true;
+      sb.append("id:");
+      sb.append(this.id);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogById_result implements TBase<getTrackLogById_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogById_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogById_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private TrackLog success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new StructMetaData(TType.STRUCT, TrackLog.class)));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogById_result.class, metaDataMap);
+    }
+    public getTrackLogById_result() {
+    }
+    public getTrackLogById_result(
+      TrackLog success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogById_result(getTrackLogById_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new TrackLog(other.success);
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public getTrackLogById_result deepCopy() {
+      return new getTrackLogById_result(this);
+    }
+    @Deprecated
+    public getTrackLogById_result clone() {
+      return new getTrackLogById_result(this);
+    }
+    public TrackLog getSuccess() {
+      return this.success;
+    }
+    public getTrackLogById_result setSuccess(TrackLog success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public getTrackLogById_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((TrackLog)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 getTrackLogById_result)
+        return this.equals((getTrackLogById_result)that);
+      return false;
+    }
+    public boolean equals(getTrackLogById_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogById_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogById_result typedOther = (getTrackLogById_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 SUCCESS:
+              if (field.type == TType.STRUCT) {
+                this.success = new TrackLog();
+                this.success.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        this.success.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogById_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogsByTracker_args implements TBase<getTrackLogsByTracker_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogsByTracker_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogsByTracker_args");
+    private static final TField TRACKER_ID_FIELD_DESC = new TField("trackerId", TType.I64, (short)1);
+    private long trackerId;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      TRACKER_ID((short)1, "trackerId");
+      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 __TRACKERID_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.TRACKER_ID, new FieldMetaData("trackerId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogsByTracker_args.class, metaDataMap);
+    }
+    public getTrackLogsByTracker_args() {
+    }
+    public getTrackLogsByTracker_args(
+      long trackerId)
+    {
+      this();
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogsByTracker_args(getTrackLogsByTracker_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.trackerId = other.trackerId;
+    }
+    public getTrackLogsByTracker_args deepCopy() {
+      return new getTrackLogsByTracker_args(this);
+    }
+    @Deprecated
+    public getTrackLogsByTracker_args clone() {
+      return new getTrackLogsByTracker_args(this);
+    }
+    public long getTrackerId() {
+      return this.trackerId;
+    }
+    public getTrackLogsByTracker_args setTrackerId(long trackerId) {
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+      return this;
+    }
+    public void unsetTrackerId() {
+      __isset_bit_vector.clear(__TRACKERID_ISSET_ID);
+    }
+    /** Returns true if field trackerId is set (has been asigned a value) and false otherwise */
+    public boolean isSetTrackerId() {
+      return __isset_bit_vector.get(__TRACKERID_ISSET_ID);
+    }
+    public void setTrackerIdIsSet(boolean value) {
+      __isset_bit_vector.set(__TRACKERID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case TRACKER_ID:
+        if (value == null) {
+          unsetTrackerId();
+        } else {
+          setTrackerId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case TRACKER_ID:
+        return new Long(getTrackerId());
+      }
+      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 TRACKER_ID:
+        return isSetTrackerId();
+      }
+      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 getTrackLogsByTracker_args)
+        return this.equals((getTrackLogsByTracker_args)that);
+      return false;
+    }
+    public boolean equals(getTrackLogsByTracker_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_trackerId = true;
+      boolean that_present_trackerId = true;
+      if (this_present_trackerId || that_present_trackerId) {
+        if (!(this_present_trackerId && that_present_trackerId))
+          return false;
+        if (this.trackerId != that.trackerId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogsByTracker_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogsByTracker_args typedOther = (getTrackLogsByTracker_args)other;
+      lastComparison = Boolean.valueOf(isSetTrackerId()).compareTo(isSetTrackerId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(trackerId, typedOther.trackerId);
+      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 TRACKER_ID:
+              if (field.type == TType.I64) {
+                this.trackerId = iprot.readI64();
+                setTrackerIdIsSet(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(TRACKER_ID_FIELD_DESC);
+      oprot.writeI64(this.trackerId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogsByTracker_args(");
+      boolean first = true;
+      sb.append("trackerId:");
+      sb.append(this.trackerId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogsByTracker_result implements TBase<getTrackLogsByTracker_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogsByTracker_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogsByTracker_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private List<TrackLog> success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new ListMetaData(TType.LIST,
+              new StructMetaData(TType.STRUCT, TrackLog.class))));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogsByTracker_result.class, metaDataMap);
+    }
+    public getTrackLogsByTracker_result() {
+    }
+    public getTrackLogsByTracker_result(
+      List<TrackLog> success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogsByTracker_result(getTrackLogsByTracker_result other) {
+      if (other.isSetSuccess()) {
+        List<TrackLog> __this__success = new ArrayList<TrackLog>();
+        for (TrackLog other_element : other.success) {
+          __this__success.add(new TrackLog(other_element));
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public getTrackLogsByTracker_result deepCopy() {
+      return new getTrackLogsByTracker_result(this);
+    }
+    @Deprecated
+    public getTrackLogsByTracker_result clone() {
+      return new getTrackLogsByTracker_result(this);
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<TrackLog> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(TrackLog elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<TrackLog>();
+      }
+      this.success.add(elem);
+    }
+    public List<TrackLog> getSuccess() {
+      return this.success;
+    }
+    public getTrackLogsByTracker_result setSuccess(List<TrackLog> success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public getTrackLogsByTracker_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<TrackLog>)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 getTrackLogsByTracker_result)
+        return this.equals((getTrackLogsByTracker_result)that);
+      return false;
+    }
+    public boolean equals(getTrackLogsByTracker_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogsByTracker_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogsByTracker_result typedOther = (getTrackLogsByTracker_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 SUCCESS:
+              if (field.type == TType.LIST) {
+                {
+                  TList _list36 = iprot.readListBegin();
+                  this.success = new ArrayList<TrackLog>(_list36.size);
+                  for (int _i37 = 0; _i37 < _list36.size; ++_i37)
+                  {
+                    TrackLog _elem38;
+                    _elem38 = new TrackLog();
+                    _elem38.read(iprot);
+                    this.success.add(_elem38);
+                  }
+                  iprot.readListEnd();
+                }
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+          for (TrackLog _iter39 : this.success)
+          {
             _iter39.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogsByTracker_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogsByUser_args implements TBase<getTrackLogsByUser_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogsByUser_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogsByUser_args");
+    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
+    private long userId;
+    /** 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");
+      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 __USERID_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.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogsByUser_args.class, metaDataMap);
+    }
+    public getTrackLogsByUser_args() {
+    }
+    public getTrackLogsByUser_args(
+      long userId)
+    {
+      this();
+      this.userId = userId;
+      setUserIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogsByUser_args(getTrackLogsByUser_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.userId = other.userId;
+    }
+    public getTrackLogsByUser_args deepCopy() {
+      return new getTrackLogsByUser_args(this);
+    }
+    @Deprecated
+    public getTrackLogsByUser_args clone() {
+      return new getTrackLogsByUser_args(this);
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public getTrackLogsByUser_args setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+      return this;
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case USER_ID:
+        return new Long(getUserId());
+      }
+      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 USER_ID:
+        return isSetUserId();
+      }
+      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 getTrackLogsByUser_args)
+        return this.equals((getTrackLogsByUser_args)that);
+      return false;
+    }
+    public boolean equals(getTrackLogsByUser_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogsByUser_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogsByUser_args typedOther = (getTrackLogsByUser_args)other;
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      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 USER_ID:
+              if (field.type == TType.I64) {
+                this.userId = iprot.readI64();
+                setUserIdIsSet(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(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogsByUser_args(");
+      boolean first = true;
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogsByUser_result implements TBase<getTrackLogsByUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogsByUser_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogsByUser_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private List<TrackLog> success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new ListMetaData(TType.LIST,
+              new StructMetaData(TType.STRUCT, TrackLog.class))));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogsByUser_result.class, metaDataMap);
+    }
+    public getTrackLogsByUser_result() {
+    }
+    public getTrackLogsByUser_result(
+      List<TrackLog> success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogsByUser_result(getTrackLogsByUser_result other) {
+      if (other.isSetSuccess()) {
+        List<TrackLog> __this__success = new ArrayList<TrackLog>();
+        for (TrackLog other_element : other.success) {
+          __this__success.add(new TrackLog(other_element));
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public getTrackLogsByUser_result deepCopy() {
+      return new getTrackLogsByUser_result(this);
+    }
+    @Deprecated
+    public getTrackLogsByUser_result clone() {
+      return new getTrackLogsByUser_result(this);
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<TrackLog> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(TrackLog elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<TrackLog>();
+      }
+      this.success.add(elem);
+    }
+    public List<TrackLog> getSuccess() {
+      return this.success;
+    }
+    public getTrackLogsByUser_result setSuccess(List<TrackLog> success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public getTrackLogsByUser_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<TrackLog>)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 getTrackLogsByUser_result)
+        return this.equals((getTrackLogsByUser_result)that);
+      return false;
+    }
+    public boolean equals(getTrackLogsByUser_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogsByUser_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogsByUser_result typedOther = (getTrackLogsByUser_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 SUCCESS:
+              if (field.type == TType.LIST) {
+                {
+                  TList _list40 = iprot.readListBegin();
+                  this.success = new ArrayList<TrackLog>(_list40.size);
+                  for (int _i41 = 0; _i41 < _list40.size; ++_i41)
+                  {
+                    TrackLog _elem42;
+                    _elem42 = new TrackLog();
+                    _elem42.read(iprot);
+                    this.success.add(_elem42);
+                  }
+                  iprot.readListEnd();
+                }
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+          for (TrackLog _iter43 : this.success)
+          {
+            _iter43.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogsByUser_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogs_args implements TBase<getTrackLogs_args._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogs_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogs_args");
+    private static final TField TRACKER_ID_FIELD_DESC = new TField("trackerId", TType.I64, (short)1);
+    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)2);
+    private static final TField EVENT_FIELD_DESC = new TField("event", TType.STRING, (short)3);
+    private static final TField URL_FIELD_DESC = new TField("url", TType.STRING, (short)4);
+    private long trackerId;
+    private long userId;
+    private String event;
+    private String url;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      TRACKER_ID((short)1, "trackerId"),
+      USER_ID((short)2, "userId"),
+      EVENT((short)3, "event"),
+      URL((short)4, "url");
+      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 __TRACKERID_ISSET_ID = 0;
+    private static final int __USERID_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.TRACKER_ID, new FieldMetaData("trackerId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.EVENT, new FieldMetaData("event", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
+      put(_Fields.URL, new FieldMetaData("url", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogs_args.class, metaDataMap);
+    }
+    public getTrackLogs_args() {
+    }
+    public getTrackLogs_args(
+      long trackerId,
+      long userId,
+      String event,
+      String url)
+    {
+      this();
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+      this.userId = userId;
+      setUserIdIsSet(true);
+      this.event = event;
+      this.url = url;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogs_args(getTrackLogs_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.trackerId = other.trackerId;
+      this.userId = other.userId;
+      if (other.isSetEvent()) {
+        this.event = other.event;
+      }
+      if (other.isSetUrl()) {
+        this.url = other.url;
+      }
+    }
+    public getTrackLogs_args deepCopy() {
+      return new getTrackLogs_args(this);
+    }
+    @Deprecated
+    public getTrackLogs_args clone() {
+      return new getTrackLogs_args(this);
+    }
+    public long getTrackerId() {
+      return this.trackerId;
+    }
+    public getTrackLogs_args setTrackerId(long trackerId) {
+      this.trackerId = trackerId;
+      setTrackerIdIsSet(true);
+      return this;
+    }
+    public void unsetTrackerId() {
+      __isset_bit_vector.clear(__TRACKERID_ISSET_ID);
+    }
+    /** Returns true if field trackerId is set (has been asigned a value) and false otherwise */
+    public boolean isSetTrackerId() {
+      return __isset_bit_vector.get(__TRACKERID_ISSET_ID);
+    }
+    public void setTrackerIdIsSet(boolean value) {
+      __isset_bit_vector.set(__TRACKERID_ISSET_ID, value);
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public getTrackLogs_args setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+      return this;
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    public String getEvent() {
+      return this.event;
+    }
+    public getTrackLogs_args setEvent(String event) {
+      this.event = event;
+      return this;
+    }
+    public void unsetEvent() {
+      this.event = null;
+    }
+    /** Returns true if field event is set (has been asigned a value) and false otherwise */
+    public boolean isSetEvent() {
+      return this.event != null;
+    }
+    public void setEventIsSet(boolean value) {
+      if (!value) {
+        this.event = null;
+      }
+    }
+    public String getUrl() {
+      return this.url;
+    }
+    public getTrackLogs_args setUrl(String url) {
+      this.url = url;
+      return this;
+    }
+    public void unsetUrl() {
+      this.url = null;
+    }
+    /** Returns true if field url is set (has been asigned a value) and false otherwise */
+    public boolean isSetUrl() {
+      return this.url != null;
+    }
+    public void setUrlIsSet(boolean value) {
+      if (!value) {
+        this.url = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case TRACKER_ID:
+        if (value == null) {
+          unsetTrackerId();
+        } else {
+          setTrackerId((Long)value);
+        }
+        break;
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      case EVENT:
+        if (value == null) {
+          unsetEvent();
+        } else {
+          setEvent((String)value);
+        }
+        break;
+      case URL:
+        if (value == null) {
+          unsetUrl();
+        } else {
+          setUrl((String)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case TRACKER_ID:
+        return new Long(getTrackerId());
+      case USER_ID:
+        return new Long(getUserId());
+      case EVENT:
+        return getEvent();
+      case URL:
+        return getUrl();
+      }
+      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 TRACKER_ID:
+        return isSetTrackerId();
+      case USER_ID:
+        return isSetUserId();
+      case EVENT:
+        return isSetEvent();
+      case URL:
+        return isSetUrl();
+      }
+      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 getTrackLogs_args)
+        return this.equals((getTrackLogs_args)that);
+      return false;
+    }
+    public boolean equals(getTrackLogs_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_trackerId = true;
+      boolean that_present_trackerId = true;
+      if (this_present_trackerId || that_present_trackerId) {
+        if (!(this_present_trackerId && that_present_trackerId))
+          return false;
+        if (this.trackerId != that.trackerId)
+          return false;
+      }
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      boolean this_present_event = true && this.isSetEvent();
+      boolean that_present_event = true && that.isSetEvent();
+      if (this_present_event || that_present_event) {
+        if (!(this_present_event && that_present_event))
+          return false;
+        if (!this.event.equals(that.event))
+          return false;
+      }
+      boolean this_present_url = true && this.isSetUrl();
+      boolean that_present_url = true && that.isSetUrl();
+      if (this_present_url || that_present_url) {
+        if (!(this_present_url && that_present_url))
+          return false;
+        if (!this.url.equals(that.url))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogs_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogs_args typedOther = (getTrackLogs_args)other;
+      lastComparison = Boolean.valueOf(isSetTrackerId()).compareTo(isSetTrackerId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(trackerId, typedOther.trackerId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetEvent()).compareTo(isSetEvent());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(event, typedOther.event);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetUrl()).compareTo(isSetUrl());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(url, typedOther.url);
+      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 TRACKER_ID:
+              if (field.type == TType.I64) {
+                this.trackerId = iprot.readI64();
+                setTrackerIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case USER_ID:
+              if (field.type == TType.I64) {
+                this.userId = iprot.readI64();
+                setUserIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case EVENT:
+              if (field.type == TType.STRING) {
+                this.event = iprot.readString();
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case URL:
+              if (field.type == TType.STRING) {
+                this.url = iprot.readString();
+              } 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(TRACKER_ID_FIELD_DESC);
+      oprot.writeI64(this.trackerId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      if (this.event != null) {
+        oprot.writeFieldBegin(EVENT_FIELD_DESC);
+        oprot.writeString(this.event);
+        oprot.writeFieldEnd();
+      }
+      if (this.url != null) {
+        oprot.writeFieldBegin(URL_FIELD_DESC);
+        oprot.writeString(this.url);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogs_args(");
+      boolean first = true;
+      sb.append("trackerId:");
+      sb.append(this.trackerId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("event:");
+      if (this.event == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.event);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("url:");
+      if (this.url == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.url);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getTrackLogs_result implements TBase<getTrackLogs_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTrackLogs_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getTrackLogs_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private static final TField UTX_FIELD_DESC = new TField("utx", TType.STRUCT, (short)1);
+    private List<TrackLog> success;
+    private UserTrackerException utx;
+    /** 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"),
+      UTX((short)1, "utx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new ListMetaData(TType.LIST,
+              new StructMetaData(TType.STRUCT, TrackLog.class))));
+      put(_Fields.UTX, new FieldMetaData("utx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getTrackLogs_result.class, metaDataMap);
+    }
+    public getTrackLogs_result() {
+    }
+    public getTrackLogs_result(
+      List<TrackLog> success,
+      UserTrackerException utx)
+    {
+      this();
+      this.success = success;
+      this.utx = utx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getTrackLogs_result(getTrackLogs_result other) {
+      if (other.isSetSuccess()) {
+        List<TrackLog> __this__success = new ArrayList<TrackLog>();
+        for (TrackLog other_element : other.success) {
+          __this__success.add(new TrackLog(other_element));
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetUtx()) {
+        this.utx = new UserTrackerException(other.utx);
+      }
+    }
+    public getTrackLogs_result deepCopy() {
+      return new getTrackLogs_result(this);
+    }
+    @Deprecated
+    public getTrackLogs_result clone() {
+      return new getTrackLogs_result(this);
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<TrackLog> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(TrackLog elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<TrackLog>();
+      }
+      this.success.add(elem);
+    }
+    public List<TrackLog> getSuccess() {
+      return this.success;
+    }
+    public getTrackLogs_result setSuccess(List<TrackLog> success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public UserTrackerException getUtx() {
+      return this.utx;
+    }
+    public getTrackLogs_result setUtx(UserTrackerException utx) {
+      this.utx = utx;
+      return this;
+    }
+    public void unsetUtx() {
+      this.utx = null;
+    }
+    /** Returns true if field utx is set (has been asigned a value) and false otherwise */
+    public boolean isSetUtx() {
+      return this.utx != null;
+    }
+    public void setUtxIsSet(boolean value) {
+      if (!value) {
+        this.utx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<TrackLog>)value);
+        }
+        break;
+      case UTX:
+        if (value == null) {
+          unsetUtx();
+        } else {
+          setUtx((UserTrackerException)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case UTX:
+        return getUtx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case UTX:
+        return isSetUtx();
+      }
+      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 getTrackLogs_result)
+        return this.equals((getTrackLogs_result)that);
+      return false;
+    }
+    public boolean equals(getTrackLogs_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_utx = true && this.isSetUtx();
+      boolean that_present_utx = true && that.isSetUtx();
+      if (this_present_utx || that_present_utx) {
+        if (!(this_present_utx && that_present_utx))
+          return false;
+        if (!this.utx.equals(that.utx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getTrackLogs_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getTrackLogs_result typedOther = (getTrackLogs_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(isSetUtx()).compareTo(isSetUtx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(utx, typedOther.utx);
+      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 SUCCESS:
+              if (field.type == TType.LIST) {
+                {
+                  TList _list44 = iprot.readListBegin();
+                  this.success = new ArrayList<TrackLog>(_list44.size);
+                  for (int _i45 = 0; _i45 < _list44.size; ++_i45)
+                  {
+                    TrackLog _elem46;
+                    _elem46 = new TrackLog();
+                    _elem46.read(iprot);
+                    this.success.add(_elem46);
+                  }
+                  iprot.readListEnd();
+                }
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case UTX:
+              if (field.type == TType.STRUCT) {
+                this.utx = new UserTrackerException();
+                this.utx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+          for (TrackLog _iter47 : this.success)
+          {
+            _iter47.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      } else if (this.isSetUtx()) {
+        oprot.writeFieldBegin(UTX_FIELD_DESC);
+        this.utx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getTrackLogs_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("utx:");
+      if (this.utx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.utx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class createCart_args implements TBase<createCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<createCart_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("createCart_args");
+    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
+    private long userId;
+    /** 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");
+      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 __USERID_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.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(createCart_args.class, metaDataMap);
+    }
+    public createCart_args() {
+    }
+    public createCart_args(
+      long userId)
+    {
+      this();
+      this.userId = userId;
+      setUserIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public createCart_args(createCart_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.userId = other.userId;
+    }
+    public createCart_args deepCopy() {
+      return new createCart_args(this);
+    }
+    @Deprecated
+    public createCart_args clone() {
+      return new createCart_args(this);
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public createCart_args setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+      return this;
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case USER_ID:
+        return new Long(getUserId());
+      }
+      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 USER_ID:
+        return isSetUserId();
+      }
+      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 createCart_args)
+        return this.equals((createCart_args)that);
+      return false;
+    }
+    public boolean equals(createCart_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(createCart_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createCart_args typedOther = (createCart_args)other;
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      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 USER_ID:
+              if (field.type == TType.I64) {
+                this.userId = iprot.readI64();
+                setUserIdIsSet(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(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("createCart_args(");
+      boolean first = true;
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class createCart_result implements TBase<createCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<createCart_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("createCart_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;
+    private ShoppingCartException scx;
+    /** 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"),
+      SCX((short)1, "scx");
+      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 __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.I64)));
+      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(createCart_result.class, metaDataMap);
+    }
+    public createCart_result() {
+    }
+    public createCart_result(
+      long success,
+      ShoppingCartException scx)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+      this.scx = scx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public createCart_result(createCart_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 createCart_result deepCopy() {
+      return new createCart_result(this);
+    }
+    @Deprecated
+    public createCart_result clone() {
+      return new createCart_result(this);
+    }
+    public long getSuccess() {
+      return this.success;
+    }
+    public createCart_result setSuccess(long 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 getScx() {
+      return this.scx;
+    }
+    public createCart_result setScx(ShoppingCartException scx) {
+      this.scx = scx;
+      return this;
+    }
+    public void unsetScx() {
+      this.scx = null;
+    }
+    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    public boolean isSetScx() {
+      return this.scx != null;
+    }
+    public void setScxIsSet(boolean value) {
+      if (!value) {
+        this.scx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Long)value);
+        }
+        break;
+      case SCX:
+        if (value == null) {
+          unsetScx();
+        } else {
+          setScx((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 Long(getSuccess());
+      case SCX:
+        return getScx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case SCX:
+        return isSetScx();
+      }
+      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 createCart_result)
+        return this.equals((createCart_result)that);
+      return false;
+    }
+    public boolean equals(createCart_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_scx = true && this.isSetScx();
+      boolean that_present_scx = true && that.isSetScx();
+      if (this_present_scx || that_present_scx) {
+        if (!(this_present_scx && that_present_scx))
+          return false;
+        if (!this.scx.equals(that.scx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(createCart_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createCart_result typedOther = (createCart_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(isSetScx()).compareTo(isSetScx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      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 SUCCESS:
+              if (field.type == TType.I64) {
+                this.success = iprot.readI64();
+                setSuccessIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case SCX:
+              if (field.type == TType.STRUCT) {
+                this.scx = new ShoppingCartException();
+                this.scx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        oprot.writeI64(this.success);
+        oprot.writeFieldEnd();
+      } else if (this.isSetScx()) {
+        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        this.scx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("createCart_result(");
+      boolean first = true;
+      sb.append("success:");
+      sb.append(this.success);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("scx:");
+      if (this.scx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.scx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCurrentCart_args implements TBase<getCurrentCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCurrentCart_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCurrentCart_args");
+    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
+    private long userId;
+    /** 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");
+      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 __USERID_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.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCurrentCart_args.class, metaDataMap);
+    }
+    public getCurrentCart_args() {
+    }
+    public getCurrentCart_args(
+      long userId)
+    {
+      this();
+      this.userId = userId;
+      setUserIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCurrentCart_args(getCurrentCart_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.userId = other.userId;
+    }
+    public getCurrentCart_args deepCopy() {
+      return new getCurrentCart_args(this);
+    }
+    @Deprecated
+    public getCurrentCart_args clone() {
+      return new getCurrentCart_args(this);
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public getCurrentCart_args setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+      return this;
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case USER_ID:
+        return new Long(getUserId());
+      }
+      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 USER_ID:
+        return isSetUserId();
+      }
+      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 getCurrentCart_args)
+        return this.equals((getCurrentCart_args)that);
+      return false;
+    }
+    public boolean equals(getCurrentCart_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCurrentCart_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCurrentCart_args typedOther = (getCurrentCart_args)other;
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      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 USER_ID:
+              if (field.type == TType.I64) {
+                this.userId = iprot.readI64();
+                setUserIdIsSet(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(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCurrentCart_args(");
+      boolean first = true;
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCurrentCart_result implements TBase<getCurrentCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCurrentCart_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCurrentCart_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
+    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private Cart success;
+    private ShoppingCartException scx;
+    /** 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"),
+      SCX((short)1, "scx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new StructMetaData(TType.STRUCT, Cart.class)));
+      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCurrentCart_result.class, metaDataMap);
+    }
+    public getCurrentCart_result() {
+    }
+    public getCurrentCart_result(
+      Cart success,
+      ShoppingCartException scx)
+    {
+      this();
+      this.success = success;
+      this.scx = scx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCurrentCart_result(getCurrentCart_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new Cart(other.success);
+      }
+      if (other.isSetScx()) {
+        this.scx = new ShoppingCartException(other.scx);
+      }
+    }
+    public getCurrentCart_result deepCopy() {
+      return new getCurrentCart_result(this);
+    }
+    @Deprecated
+    public getCurrentCart_result clone() {
+      return new getCurrentCart_result(this);
+    }
+    public Cart getSuccess() {
+      return this.success;
+    }
+    public getCurrentCart_result setSuccess(Cart success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public ShoppingCartException getScx() {
+      return this.scx;
+    }
+    public getCurrentCart_result setScx(ShoppingCartException scx) {
+      this.scx = scx;
+      return this;
+    }
+    public void unsetScx() {
+      this.scx = null;
+    }
+    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    public boolean isSetScx() {
+      return this.scx != null;
+    }
+    public void setScxIsSet(boolean value) {
+      if (!value) {
+        this.scx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Cart)value);
+        }
+        break;
+      case SCX:
+        if (value == null) {
+          unsetScx();
+        } else {
+          setScx((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 getSuccess();
+      case SCX:
+        return getScx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case SCX:
+        return isSetScx();
+      }
+      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 getCurrentCart_result)
+        return this.equals((getCurrentCart_result)that);
+      return false;
+    }
+    public boolean equals(getCurrentCart_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_scx = true && this.isSetScx();
+      boolean that_present_scx = true && that.isSetScx();
+      if (this_present_scx || that_present_scx) {
+        if (!(this_present_scx && that_present_scx))
+          return false;
+        if (!this.scx.equals(that.scx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCurrentCart_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCurrentCart_result typedOther = (getCurrentCart_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(isSetScx()).compareTo(isSetScx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      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 SUCCESS:
+              if (field.type == TType.STRUCT) {
+                this.success = new Cart();
+                this.success.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case SCX:
+              if (field.type == TType.STRUCT) {
+                this.scx = new ShoppingCartException();
+                this.scx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        this.success.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetScx()) {
+        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        this.scx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCurrentCart_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("scx:");
+      if (this.scx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.scx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCart_args implements TBase<getCart_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCart_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCart_args");
+    private static final TField CART_ID_FIELD_DESC = new TField("cartId", TType.I64, (short)1);
+    private long cartId;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      CART_ID((short)1, "cartId");
+      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 __CARTID_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.CART_ID, new FieldMetaData("cartId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCart_args.class, metaDataMap);
+    }
+    public getCart_args() {
+    }
+    public getCart_args(
+      long cartId)
+    {
+      this();
+      this.cartId = cartId;
+      setCartIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCart_args(getCart_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.cartId = other.cartId;
+    }
+    public getCart_args deepCopy() {
+      return new getCart_args(this);
+    }
+    @Deprecated
+    public getCart_args clone() {
+      return new getCart_args(this);
+    }
+    public long getCartId() {
+      return this.cartId;
+    }
+    public getCart_args setCartId(long cartId) {
+      this.cartId = cartId;
+      setCartIdIsSet(true);
+      return this;
+    }
+    public void unsetCartId() {
+      __isset_bit_vector.clear(__CARTID_ISSET_ID);
+    }
+    /** Returns true if field cartId is set (has been asigned a value) and false otherwise */
+    public boolean isSetCartId() {
+      return __isset_bit_vector.get(__CARTID_ISSET_ID);
+    }
+    public void setCartIdIsSet(boolean value) {
+      __isset_bit_vector.set(__CARTID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case CART_ID:
+        if (value == null) {
+          unsetCartId();
+        } else {
+          setCartId((Long)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case CART_ID:
+        return new Long(getCartId());
+      }
+      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 CART_ID:
+        return isSetCartId();
+      }
+      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 getCart_args)
+        return this.equals((getCart_args)that);
+      return false;
+    }
+    public boolean equals(getCart_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_cartId = true;
+      boolean that_present_cartId = true;
+      if (this_present_cartId || that_present_cartId) {
+        if (!(this_present_cartId && that_present_cartId))
+          return false;
+        if (this.cartId != that.cartId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCart_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCart_args typedOther = (getCart_args)other;
+      lastComparison = Boolean.valueOf(isSetCartId()).compareTo(isSetCartId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(cartId, typedOther.cartId);
+      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 CART_ID:
+              if (field.type == TType.I64) {
+                this.cartId = iprot.readI64();
+                setCartIdIsSet(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(CART_ID_FIELD_DESC);
+      oprot.writeI64(this.cartId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCart_args(");
+      boolean first = true;
+      sb.append("cartId:");
+      sb.append(this.cartId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCart_result implements TBase<getCart_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCart_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCart_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
+    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private Cart success;
+    private ShoppingCartException scx;
+    /** 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"),
+      SCX((short)1, "scx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new StructMetaData(TType.STRUCT, Cart.class)));
+      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCart_result.class, metaDataMap);
+    }
+    public getCart_result() {
+    }
+    public getCart_result(
+      Cart success,
+      ShoppingCartException scx)
+    {
+      this();
+      this.success = success;
+      this.scx = scx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCart_result(getCart_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new Cart(other.success);
+      }
+      if (other.isSetScx()) {
+        this.scx = new ShoppingCartException(other.scx);
+      }
+    }
+    public getCart_result deepCopy() {
+      return new getCart_result(this);
+    }
+    @Deprecated
+    public getCart_result clone() {
+      return new getCart_result(this);
+    }
+    public Cart getSuccess() {
+      return this.success;
+    }
+    public getCart_result setSuccess(Cart success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public ShoppingCartException getScx() {
+      return this.scx;
+    }
+    public getCart_result setScx(ShoppingCartException scx) {
+      this.scx = scx;
+      return this;
+    }
+    public void unsetScx() {
+      this.scx = null;
+    }
+    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    public boolean isSetScx() {
+      return this.scx != null;
+    }
+    public void setScxIsSet(boolean value) {
+      if (!value) {
+        this.scx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Cart)value);
+        }
+        break;
+      case SCX:
+        if (value == null) {
+          unsetScx();
+        } else {
+          setScx((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 getSuccess();
+      case SCX:
+        return getScx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case SCX:
+        return isSetScx();
+      }
+      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 getCart_result)
+        return this.equals((getCart_result)that);
+      return false;
+    }
+    public boolean equals(getCart_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_scx = true && this.isSetScx();
+      boolean that_present_scx = true && that.isSetScx();
+      if (this_present_scx || that_present_scx) {
+        if (!(this_present_scx && that_present_scx))
+          return false;
+        if (!this.scx.equals(that.scx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCart_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCart_result typedOther = (getCart_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(isSetScx()).compareTo(isSetScx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      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 SUCCESS:
+              if (field.type == TType.STRUCT) {
+                this.success = new Cart();
+                this.success.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case SCX:
+              if (field.type == TType.STRUCT) {
+                this.scx = new ShoppingCartException();
+                this.scx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        this.success.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetScx()) {
+        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        this.scx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCart_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("scx:");
+      if (this.scx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.scx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCartsForUser_args implements TBase<getCartsForUser_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsForUser_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCartsForUser_args");
+    private static final TField USER_ID_FIELD_DESC = new TField("userId", TType.I64, (short)1);
+    private static final TField STATUS_FIELD_DESC = new TField("status", TType.I32, (short)2);
+    private long userId;
+    private CartStatus status;
+    /** 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"),
+      /**
+       *
+       * @see CartStatus
+       */
+      STATUS((short)2, "status");
+      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 __USERID_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.USER_ID, new FieldMetaData("userId", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.STATUS, new FieldMetaData("status", TFieldRequirementType.DEFAULT,
+          new EnumMetaData(TType.ENUM, CartStatus.class)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCartsForUser_args.class, metaDataMap);
+    }
+    public getCartsForUser_args() {
+    }
+    public getCartsForUser_args(
+      long userId,
+      CartStatus status)
+    {
+      this();
+      this.userId = userId;
+      setUserIdIsSet(true);
+      this.status = status;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCartsForUser_args(getCartsForUser_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.userId = other.userId;
+      if (other.isSetStatus()) {
+        this.status = other.status;
+      }
+    }
+    public getCartsForUser_args deepCopy() {
+      return new getCartsForUser_args(this);
+    }
+    @Deprecated
+    public getCartsForUser_args clone() {
+      return new getCartsForUser_args(this);
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public getCartsForUser_args setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+      return this;
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been asigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    /**
+     *
+     * @see CartStatus
+     */
+    public CartStatus getStatus() {
+      return this.status;
+    }
+    /**
+     *
+     * @see CartStatus
+     */
+    public getCartsForUser_args setStatus(CartStatus status) {
+      this.status = status;
+      return this;
+    }
+    public void unsetStatus() {
+      this.status = null;
+    }
+    /** Returns true if field status is set (has been asigned a value) and false otherwise */
+    public boolean isSetStatus() {
+      return this.status != null;
+    }
+    public void setStatusIsSet(boolean value) {
+      if (!value) {
+        this.status = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      case STATUS:
+        if (value == null) {
+          unsetStatus();
+        } else {
+          setStatus((CartStatus)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case USER_ID:
+        return new Long(getUserId());
+      case STATUS:
+        return getStatus();
+      }
+      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 USER_ID:
+        return isSetUserId();
+      case STATUS:
+        return isSetStatus();
+      }
+      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 getCartsForUser_args)
+        return this.equals((getCartsForUser_args)that);
+      return false;
+    }
+    public boolean equals(getCartsForUser_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      boolean this_present_status = true && this.isSetStatus();
+      boolean that_present_status = true && that.isSetStatus();
+      if (this_present_status || that_present_status) {
+        if (!(this_present_status && that_present_status))
+          return false;
+        if (!this.status.equals(that.status))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCartsForUser_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCartsForUser_args typedOther = (getCartsForUser_args)other;
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(userId, typedOther.userId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetStatus()).compareTo(isSetStatus());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(status, typedOther.status);
+      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 USER_ID:
+              if (field.type == TType.I64) {
+                this.userId = iprot.readI64();
+                setUserIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case STATUS:
+              if (field.type == TType.I32) {
+                this.status = CartStatus.findByValue(iprot.readI32());
+              } 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(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      if (this.status != null) {
+        oprot.writeFieldBegin(STATUS_FIELD_DESC);
+        oprot.writeI32(this.status.getValue());
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCartsForUser_args(");
+      boolean first = true;
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("status:");
+      if (this.status == null) {
+        sb.append("null");
+      } else {
+        String status_name = status.name();
+        if (status_name != null) {
+          sb.append(status_name);
+          sb.append(" (");
+        }
+        sb.append(this.status);
+        if (status_name != null) {
+          sb.append(")");
+        }
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCartsForUser_result implements TBase<getCartsForUser_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsForUser_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCartsForUser_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private List<Cart> success;
+    private ShoppingCartException scx;
+    /** 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"),
+      SCX((short)1, "scx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new ListMetaData(TType.LIST,
+              new StructMetaData(TType.STRUCT, Cart.class))));
+      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCartsForUser_result.class, metaDataMap);
+    }
+    public getCartsForUser_result() {
+    }
+    public getCartsForUser_result(
+      List<Cart> success,
+      ShoppingCartException scx)
+    {
+      this();
+      this.success = success;
+      this.scx = scx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCartsForUser_result(getCartsForUser_result other) {
+      if (other.isSetSuccess()) {
+        List<Cart> __this__success = new ArrayList<Cart>();
+        for (Cart other_element : other.success) {
+          __this__success.add(new Cart(other_element));
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetScx()) {
+        this.scx = new ShoppingCartException(other.scx);
+      }
+    }
+    public getCartsForUser_result deepCopy() {
+      return new getCartsForUser_result(this);
+    }
+    @Deprecated
+    public getCartsForUser_result clone() {
+      return new getCartsForUser_result(this);
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<Cart> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(Cart elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<Cart>();
+      }
+      this.success.add(elem);
+    }
+    public List<Cart> getSuccess() {
+      return this.success;
+    }
+    public getCartsForUser_result setSuccess(List<Cart> success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public ShoppingCartException getScx() {
+      return this.scx;
+    }
+    public getCartsForUser_result setScx(ShoppingCartException scx) {
+      this.scx = scx;
+      return this;
+    }
+    public void unsetScx() {
+      this.scx = null;
+    }
+    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    public boolean isSetScx() {
+      return this.scx != null;
+    }
+    public void setScxIsSet(boolean value) {
+      if (!value) {
+        this.scx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<Cart>)value);
+        }
+        break;
+      case SCX:
+        if (value == null) {
+          unsetScx();
+        } else {
+          setScx((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 getSuccess();
+      case SCX:
+        return getScx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case SCX:
+        return isSetScx();
+      }
+      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 getCartsForUser_result)
+        return this.equals((getCartsForUser_result)that);
+      return false;
+    }
+    public boolean equals(getCartsForUser_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_scx = true && this.isSetScx();
+      boolean that_present_scx = true && that.isSetScx();
+      if (this_present_scx || that_present_scx) {
+        if (!(this_present_scx && that_present_scx))
+          return false;
+        if (!this.scx.equals(that.scx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCartsForUser_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCartsForUser_result typedOther = (getCartsForUser_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(isSetScx()).compareTo(isSetScx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      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 SUCCESS:
+              if (field.type == TType.LIST) {
+                {
+                  TList _list48 = iprot.readListBegin();
+                  this.success = new ArrayList<Cart>(_list48.size);
+                  for (int _i49 = 0; _i49 < _list48.size; ++_i49)
+                  {
+                    Cart _elem50;
+                    _elem50 = new Cart();
+                    _elem50.read(iprot);
+                    this.success.add(_elem50);
+                  }
+                  iprot.readListEnd();
+                }
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case SCX:
+              if (field.type == TType.STRUCT) {
+                this.scx = new ShoppingCartException();
+                this.scx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+          for (Cart _iter51 : this.success)
+          {
+            _iter51.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      } else if (this.isSetScx()) {
+        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        this.scx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCartsForUser_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("scx:");
+      if (this.scx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.scx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCartsByStatus_args implements TBase<getCartsByStatus_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByStatus_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCartsByStatus_args");
+    private static final TField STATUS_FIELD_DESC = new TField("status", TType.I32, (short)1);
+    private CartStatus status;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      /**
+       *
+       * @see CartStatus
+       */
+      STATUS((short)1, "status");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.STATUS, new FieldMetaData("status", TFieldRequirementType.DEFAULT,
+          new EnumMetaData(TType.ENUM, CartStatus.class)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCartsByStatus_args.class, metaDataMap);
+    }
+    public getCartsByStatus_args() {
+    }
+    public getCartsByStatus_args(
+      CartStatus status)
+    {
+      this();
+      this.status = status;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCartsByStatus_args(getCartsByStatus_args other) {
+      if (other.isSetStatus()) {
+        this.status = other.status;
+      }
+    }
+    public getCartsByStatus_args deepCopy() {
+      return new getCartsByStatus_args(this);
+    }
+    @Deprecated
+    public getCartsByStatus_args clone() {
+      return new getCartsByStatus_args(this);
+    }
+    /**
+     *
+     * @see CartStatus
+     */
+    public CartStatus getStatus() {
+      return this.status;
+    }
+    /**
+     *
+     * @see CartStatus
+     */
+    public getCartsByStatus_args setStatus(CartStatus status) {
+      this.status = status;
+      return this;
+    }
+    public void unsetStatus() {
+      this.status = null;
+    }
+    /** Returns true if field status is set (has been asigned a value) and false otherwise */
+    public boolean isSetStatus() {
+      return this.status != null;
+    }
+    public void setStatusIsSet(boolean value) {
+      if (!value) {
+        this.status = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case STATUS:
+        if (value == null) {
+          unsetStatus();
+        } else {
+          setStatus((CartStatus)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case STATUS:
+        return getStatus();
+      }
+      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 STATUS:
+        return isSetStatus();
+      }
+      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 getCartsByStatus_args)
+        return this.equals((getCartsByStatus_args)that);
+      return false;
+    }
+    public boolean equals(getCartsByStatus_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_status = true && this.isSetStatus();
+      boolean that_present_status = true && that.isSetStatus();
+      if (this_present_status || that_present_status) {
+        if (!(this_present_status && that_present_status))
+          return false;
+        if (!this.status.equals(that.status))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCartsByStatus_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCartsByStatus_args typedOther = (getCartsByStatus_args)other;
+      lastComparison = Boolean.valueOf(isSetStatus()).compareTo(isSetStatus());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(status, typedOther.status);
+      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 STATUS:
+              if (field.type == TType.I32) {
+                this.status = CartStatus.findByValue(iprot.readI32());
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.status != null) {
+        oprot.writeFieldBegin(STATUS_FIELD_DESC);
+        oprot.writeI32(this.status.getValue());
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCartsByStatus_args(");
+      boolean first = true;
+      sb.append("status:");
+      if (this.status == null) {
+        sb.append("null");
+      } else {
+        String status_name = status.name();
+        if (status_name != null) {
+          sb.append(status_name);
+          sb.append(" (");
+        }
+        sb.append(this.status);
+        if (status_name != null) {
+          sb.append(")");
+        }
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCartsByStatus_result implements TBase<getCartsByStatus_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByStatus_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCartsByStatus_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private List<Cart> success;
+    private ShoppingCartException scx;
+    /** 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"),
+      SCX((short)1, "scx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new ListMetaData(TType.LIST,
+              new StructMetaData(TType.STRUCT, Cart.class))));
+      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCartsByStatus_result.class, metaDataMap);
+    }
+    public getCartsByStatus_result() {
+    }
+    public getCartsByStatus_result(
+      List<Cart> success,
+      ShoppingCartException scx)
+    {
+      this();
+      this.success = success;
+      this.scx = scx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCartsByStatus_result(getCartsByStatus_result other) {
+      if (other.isSetSuccess()) {
+        List<Cart> __this__success = new ArrayList<Cart>();
+        for (Cart other_element : other.success) {
+          __this__success.add(new Cart(other_element));
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetScx()) {
+        this.scx = new ShoppingCartException(other.scx);
+      }
+    }
+    public getCartsByStatus_result deepCopy() {
+      return new getCartsByStatus_result(this);
+    }
+    @Deprecated
+    public getCartsByStatus_result clone() {
+      return new getCartsByStatus_result(this);
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<Cart> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(Cart elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<Cart>();
+      }
+      this.success.add(elem);
+    }
+    public List<Cart> getSuccess() {
+      return this.success;
+    }
+    public getCartsByStatus_result setSuccess(List<Cart> success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public ShoppingCartException getScx() {
+      return this.scx;
+    }
+    public getCartsByStatus_result setScx(ShoppingCartException scx) {
+      this.scx = scx;
+      return this;
+    }
+    public void unsetScx() {
+      this.scx = null;
+    }
+    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    public boolean isSetScx() {
+      return this.scx != null;
+    }
+    public void setScxIsSet(boolean value) {
+      if (!value) {
+        this.scx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<Cart>)value);
+        }
+        break;
+      case SCX:
+        if (value == null) {
+          unsetScx();
+        } else {
+          setScx((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 getSuccess();
+      case SCX:
+        return getScx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case SCX:
+        return isSetScx();
+      }
+      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 getCartsByStatus_result)
+        return this.equals((getCartsByStatus_result)that);
+      return false;
+    }
+    public boolean equals(getCartsByStatus_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_scx = true && this.isSetScx();
+      boolean that_present_scx = true && that.isSetScx();
+      if (this_present_scx || that_present_scx) {
+        if (!(this_present_scx && that_present_scx))
+          return false;
+        if (!this.scx.equals(that.scx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCartsByStatus_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCartsByStatus_result typedOther = (getCartsByStatus_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(isSetScx()).compareTo(isSetScx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      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 SUCCESS:
+              if (field.type == TType.LIST) {
+                {
+                  TList _list52 = iprot.readListBegin();
+                  this.success = new ArrayList<Cart>(_list52.size);
+                  for (int _i53 = 0; _i53 < _list52.size; ++_i53)
+                  {
+                    Cart _elem54;
+                    _elem54 = new Cart();
+                    _elem54.read(iprot);
+                    this.success.add(_elem54);
+                  }
+                  iprot.readListEnd();
+                }
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case SCX:
+              if (field.type == TType.STRUCT) {
+                this.scx = new ShoppingCartException();
+                this.scx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+          for (Cart _iter55 : this.success)
+          {
+            _iter55.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      } else if (this.isSetScx()) {
+        oprot.writeFieldBegin(SCX_FIELD_DESC);
+        this.scx.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCartsByStatus_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("scx:");
+      if (this.scx == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.scx);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCartsByTime_args implements TBase<getCartsByTime_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByTime_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCartsByTime_args");
+    private static final TField FROM_TIME_FIELD_DESC = new TField("from_time", TType.I64, (short)1);
+    private static final TField TO_TIME_FIELD_DESC = new TField("to_time", TType.I64, (short)2);
+    private static final TField STATUS_FIELD_DESC = new TField("status", TType.I32, (short)3);
+    private long from_time;
+    private long to_time;
+    private CartStatus status;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      FROM_TIME((short)1, "from_time"),
+      TO_TIME((short)2, "to_time"),
+      /**
+       *
+       * @see CartStatus
+       */
+      STATUS((short)3, "status");
+      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 __FROM_TIME_ISSET_ID = 0;
+    private static final int __TO_TIME_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_TIME, new FieldMetaData("from_time", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.TO_TIME, new FieldMetaData("to_time", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
+      put(_Fields.STATUS, new FieldMetaData("status", TFieldRequirementType.DEFAULT,
+          new EnumMetaData(TType.ENUM, CartStatus.class)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCartsByTime_args.class, metaDataMap);
+    }
+    public getCartsByTime_args() {
+    }
+    public getCartsByTime_args(
+      long from_time,
+      long to_time,
+      CartStatus status)
+    {
+      this();
+      this.from_time = from_time;
+      setFrom_timeIsSet(true);
+      this.to_time = to_time;
+      setTo_timeIsSet(true);
+      this.status = status;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCartsByTime_args(getCartsByTime_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.from_time = other.from_time;
+      this.to_time = other.to_time;
+      if (other.isSetStatus()) {
+        this.status = other.status;
+      }
+    }
+    public getCartsByTime_args deepCopy() {
+      return new getCartsByTime_args(this);
+    }
+    @Deprecated
+    public getCartsByTime_args clone() {
+      return new getCartsByTime_args(this);
+    }
+    public long getFrom_time() {
+      return this.from_time;
+    }
+    public getCartsByTime_args setFrom_time(long from_time) {
+      this.from_time = from_time;
+      setFrom_timeIsSet(true);
+      return this;
+    }
+    public void unsetFrom_time() {
+      __isset_bit_vector.clear(__FROM_TIME_ISSET_ID);
+    }
+    /** Returns true if field from_time is set (has been asigned a value) and false otherwise */
+    public boolean isSetFrom_time() {
+      return __isset_bit_vector.get(__FROM_TIME_ISSET_ID);
+    }
+    public void setFrom_timeIsSet(boolean value) {
+      __isset_bit_vector.set(__FROM_TIME_ISSET_ID, value);
+    }
+    public long getTo_time() {
+      return this.to_time;
+    }
+    public getCartsByTime_args setTo_time(long to_time) {
+      this.to_time = to_time;
+      setTo_timeIsSet(true);
+      return this;
+    }
+    public void unsetTo_time() {
+      __isset_bit_vector.clear(__TO_TIME_ISSET_ID);
+    }
+    /** Returns true if field to_time is set (has been asigned a value) and false otherwise */
+    public boolean isSetTo_time() {
+      return __isset_bit_vector.get(__TO_TIME_ISSET_ID);
+    }
+    public void setTo_timeIsSet(boolean value) {
+      __isset_bit_vector.set(__TO_TIME_ISSET_ID, value);
+    }
+    /**
+     *
+     * @see CartStatus
+     */
+    public CartStatus getStatus() {
+      return this.status;
+    }
+    /**
+     *
+     * @see CartStatus
+     */
+    public getCartsByTime_args setStatus(CartStatus status) {
+      this.status = status;
+      return this;
+    }
+    public void unsetStatus() {
+      this.status = null;
+    }
+    /** Returns true if field status is set (has been asigned a value) and false otherwise */
+    public boolean isSetStatus() {
+      return this.status != null;
+    }
+    public void setStatusIsSet(boolean value) {
+      if (!value) {
+        this.status = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case FROM_TIME:
+        if (value == null) {
+          unsetFrom_time();
+        } else {
+          setFrom_time((Long)value);
+        }
+        break;
+      case TO_TIME:
+        if (value == null) {
+          unsetTo_time();
+        } else {
+          setTo_time((Long)value);
+        }
+        break;
+      case STATUS:
+        if (value == null) {
+          unsetStatus();
+        } else {
+          setStatus((CartStatus)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case FROM_TIME:
+        return new Long(getFrom_time());
+      case TO_TIME:
+        return new Long(getTo_time());
+      case STATUS:
+        return getStatus();
+      }
+      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_TIME:
+        return isSetFrom_time();
+      case TO_TIME:
+        return isSetTo_time();
+      case STATUS:
+        return isSetStatus();
+      }
+      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 getCartsByTime_args)
+        return this.equals((getCartsByTime_args)that);
+      return false;
+    }
+    public boolean equals(getCartsByTime_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_from_time = true;
+      boolean that_present_from_time = true;
+      if (this_present_from_time || that_present_from_time) {
+        if (!(this_present_from_time && that_present_from_time))
+          return false;
+        if (this.from_time != that.from_time)
+          return false;
+      }
+      boolean this_present_to_time = true;
+      boolean that_present_to_time = true;
+      if (this_present_to_time || that_present_to_time) {
+        if (!(this_present_to_time && that_present_to_time))
+          return false;
+        if (this.to_time != that.to_time)
+          return false;
+      }
+      boolean this_present_status = true && this.isSetStatus();
+      boolean that_present_status = true && that.isSetStatus();
+      if (this_present_status || that_present_status) {
+        if (!(this_present_status && that_present_status))
+          return false;
+        if (!this.status.equals(that.status))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCartsByTime_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCartsByTime_args typedOther = (getCartsByTime_args)other;
+      lastComparison = Boolean.valueOf(isSetFrom_time()).compareTo(isSetFrom_time());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(from_time, typedOther.from_time);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetTo_time()).compareTo(isSetTo_time());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(to_time, typedOther.to_time);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetStatus()).compareTo(isSetStatus());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(status, typedOther.status);
+      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_TIME:
+              if (field.type == TType.I64) {
+                this.from_time = iprot.readI64();
+                setFrom_timeIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case TO_TIME:
+              if (field.type == TType.I64) {
+                this.to_time = iprot.readI64();
+                setTo_timeIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case STATUS:
+              if (field.type == TType.I32) {
+                this.status = CartStatus.findByValue(iprot.readI32());
+              } 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_TIME_FIELD_DESC);
+      oprot.writeI64(this.from_time);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(TO_TIME_FIELD_DESC);
+      oprot.writeI64(this.to_time);
+      oprot.writeFieldEnd();
+      if (this.status != null) {
+        oprot.writeFieldBegin(STATUS_FIELD_DESC);
+        oprot.writeI32(this.status.getValue());
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getCartsByTime_args(");
+      boolean first = true;
+      sb.append("from_time:");
+      sb.append(this.from_time);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("to_time:");
+      sb.append(this.to_time);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("status:");
+      if (this.status == null) {
+        sb.append("null");
+      } else {
+        String status_name = status.name();
+        if (status_name != null) {
+          sb.append(status_name);
+          sb.append(" (");
+        }
+        sb.append(this.status);
+        if (status_name != null) {
+          sb.append(")");
+        }
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getCartsByTime_result implements TBase<getCartsByTime_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCartsByTime_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getCartsByTime_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private static final TField SCX_FIELD_DESC = new TField("scx", TType.STRUCT, (short)1);
+    private List<Cart> success;
+    private ShoppingCartException scx;
+    /** 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"),
+      SCX((short)1, "scx");
+      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
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new ListMetaData(TType.LIST,
+              new StructMetaData(TType.STRUCT, Cart.class))));
+      put(_Fields.SCX, new FieldMetaData("scx", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRUCT)));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getCartsByTime_result.class, metaDataMap);
+    }
+    public getCartsByTime_result() {
+    }
+    public getCartsByTime_result(
+      List<Cart> success,
+      ShoppingCartException scx)
+    {
+      this();
+      this.success = success;
+      this.scx = scx;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getCartsByTime_result(getCartsByTime_result other) {
+      if (other.isSetSuccess()) {
+        List<Cart> __this__success = new ArrayList<Cart>();
+        for (Cart other_element : other.success) {
+          __this__success.add(new Cart(other_element));
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetScx()) {
+        this.scx = new ShoppingCartException(other.scx);
+      }
+    }
+    public getCartsByTime_result deepCopy() {
+      return new getCartsByTime_result(this);
+    }
+    @Deprecated
+    public getCartsByTime_result clone() {
+      return new getCartsByTime_result(this);
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<Cart> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(Cart elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<Cart>();
+      }
+      this.success.add(elem);
+    }
+    public List<Cart> getSuccess() {
+      return this.success;
+    }
+    public getCartsByTime_result setSuccess(List<Cart> success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public ShoppingCartException getScx() {
+      return this.scx;
+    }
+    public getCartsByTime_result setScx(ShoppingCartException scx) {
+      this.scx = scx;
+      return this;
+    }
+    public void unsetScx() {
+      this.scx = null;
+    }
+    /** Returns true if field scx is set (has been asigned a value) and false otherwise */
+    public boolean isSetScx() {
+      return this.scx != null;
+    }
+    public void setScxIsSet(boolean value) {
+      if (!value) {
+        this.scx = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<Cart>)value);
+        }
+        break;
+      case SCX:
+        if (value == null) {
+          unsetScx();
+        } else {
+          setScx((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 getSuccess();
+      case SCX:
+        return getScx();
+      }
+      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 SUCCESS:
+        return isSetSuccess();
+      case SCX:
+        return isSetScx();
+      }
+      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 getCartsByTime_result)
+        return this.equals((getCartsByTime_result)that);
+      return false;
+    }
+    public boolean equals(getCartsByTime_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_scx = true && this.isSetScx();
+      boolean that_present_scx = true && that.isSetScx();
+      if (this_present_scx || that_present_scx) {
+        if (!(this_present_scx && that_present_scx))
+          return false;
+        if (!this.scx.equals(that.scx))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getCartsByTime_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getCartsByTime_result typedOther = (getCartsByTime_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(isSetScx()).compareTo(isSetScx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(scx, typedOther.scx);
+      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 SUCCESS:
+              if (field.type == TType.LIST) {
+                {
+                  TList _list56 = iprot.readListBegin();
+                  this.success = new ArrayList<Cart>(_list56.size);
+                  for (int _i57 = 0; _i57 < _list56.size; ++_i57)
+                  {
+                    Cart _elem58;
+                    _elem58 = new Cart();
+                    _elem58.read(iprot);
+                    this.success.add(_elem58);
+                  }
+                  iprot.readListEnd();
+                }
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case SCX:
+              if (field.type == TType.STRUCT) {
+                this.scx = new ShoppingCartException();
+                this.scx.read(iprot);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+          for (Cart _iter59 : this.success)
+          {
+            _iter59.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetScx()) {
+              }
               break;
             case ITEMS:
               if (field.type == TType.MAP) {
+                {
-                  TMap _map40 = iprot.readMapBegin();
+                  TMap _map60 = iprot.readMapBegin();
-                  this.items = new HashMap<Long,Double>(2*_map40.size);
+                  this.items = new HashMap<Long,Double>(2*_map60.size);
-                  for (int _i41 = 0; _i41 < _map40.size; ++_i41)
+                  for (int _i61 = 0; _i61 < _map60.size; ++_i61)
+                  {
-                    long _key42;
+                    long _key62;
-                    double _val43;
+                    double _val63;
-                    _key42 = iprot.readI64();
+                    _key62 = iprot.readI64();
-                    _val43 = iprot.readDouble();
+                    _val63 = iprot.readDouble();
-                    this.items.put(_key42, _val43);
+                    this.items.put(_key62, _val63);
+                  }
                   iprot.readMapEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.items != null) {
         oprot.writeFieldBegin(ITEMS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new TMap(TType.I64, TType.DOUBLE, this.items.size()));
-          for (Map.Entry<Long, Double> _iter44 : this.items.entrySet())
+          for (Map.Entry<Long, Double> _iter64 : this.items.entrySet())
+          {
-            oprot.writeI64(_iter44.getKey());
+            oprot.writeI64(_iter64.getKey());
-            oprot.writeDouble(_iter44.getValue());
+            oprot.writeDouble(_iter64.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list45 = iprot.readListBegin();
+                  TList _list65 = iprot.readListBegin();
-                  this.success = new ArrayList<User>(_list45.size);
+                  this.success = new ArrayList<User>(_list65.size);
-                  for (int _i46 = 0; _i46 < _list45.size; ++_i46)
+                  for (int _i66 = 0; _i66 < _list65.size; ++_i66)
+                  {
-                    User _elem47;
+                    User _elem67;
-                    _elem47 = new User();
+                    _elem67 = new User();
-                    _elem47.read(iprot);
+                    _elem67.read(iprot);
-                    this.success.add(_elem47);
+                    this.success.add(_elem67);
+                  }
                   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 (User _iter48 : this.success)
+          for (User _iter68 : this.success)
+          {
-            _iter48.write(oprot);
+            _iter68.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/user/UserContextService.java – Rev 1674 → 1846