Subversion Repositories SmartDukaan

Rev

Rev 6747 | Rev 6903 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 6747 Rev 6821
Line 906... Line 906...
906
 
906
 
907
    public Map<Long,Double> getMiscCharges(long transactionId) throws org.apache.thrift.TException;
907
    public Map<Long,Double> getMiscCharges(long transactionId) throws org.apache.thrift.TException;
908
 
908
 
909
    public boolean refundRechargeOrder(long rechargeOrderId) throws TransactionServiceException, org.apache.thrift.TException;
909
    public boolean refundRechargeOrder(long rechargeOrderId) throws TransactionServiceException, org.apache.thrift.TException;
910
 
910
 
-
 
911
    public List<Order> getPhysicalOrders(long fromDate, long toDate) throws org.apache.thrift.TException;
-
 
912
 
911
  }
913
  }
912
 
914
 
913
  public interface AsyncIface extends in.shop2020.generic.GenericService .AsyncIface {
915
  public interface AsyncIface extends in.shop2020.generic.GenericService .AsyncIface {
914
 
916
 
915
    public void createTransaction(Transaction transaction, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.createTransaction_call> resultHandler) throws org.apache.thrift.TException;
917
    public void createTransaction(Transaction transaction, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.createTransaction_call> resultHandler) throws org.apache.thrift.TException;
Line 1206... Line 1208...
1206
 
1208
 
1207
    public void getMiscCharges(long transactionId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMiscCharges_call> resultHandler) throws org.apache.thrift.TException;
1209
    public void getMiscCharges(long transactionId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getMiscCharges_call> resultHandler) throws org.apache.thrift.TException;
1208
 
1210
 
1209
    public void refundRechargeOrder(long rechargeOrderId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.refundRechargeOrder_call> resultHandler) throws org.apache.thrift.TException;
1211
    public void refundRechargeOrder(long rechargeOrderId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.refundRechargeOrder_call> resultHandler) throws org.apache.thrift.TException;
1210
 
1212
 
-
 
1213
    public void getPhysicalOrders(long fromDate, long toDate, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getPhysicalOrders_call> resultHandler) throws org.apache.thrift.TException;
-
 
1214
 
1211
  }
1215
  }
1212
 
1216
 
1213
  public static class Client extends in.shop2020.generic.GenericService.Client implements Iface {
1217
  public static class Client extends in.shop2020.generic.GenericService.Client implements Iface {
1214
    public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
1218
    public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
1215
      public Factory() {}
1219
      public Factory() {}
Line 4959... Line 4963...
4959
        throw result.ex;
4963
        throw result.ex;
4960
      }
4964
      }
4961
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
4965
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
4962
    }
4966
    }
4963
 
4967
 
-
 
4968
    public List<Order> getPhysicalOrders(long fromDate, long toDate) throws org.apache.thrift.TException
-
 
4969
    {
-
 
4970
      send_getPhysicalOrders(fromDate, toDate);
-
 
4971
      return recv_getPhysicalOrders();
-
 
4972
    }
-
 
4973
 
-
 
4974
    public void send_getPhysicalOrders(long fromDate, long toDate) throws org.apache.thrift.TException
-
 
4975
    {
-
 
4976
      getPhysicalOrders_args args = new getPhysicalOrders_args();
-
 
4977
      args.setFromDate(fromDate);
-
 
4978
      args.setToDate(toDate);
-
 
4979
      sendBase("getPhysicalOrders", args);
-
 
4980
    }
-
 
4981
 
-
 
4982
    public List<Order> recv_getPhysicalOrders() throws org.apache.thrift.TException
-
 
4983
    {
-
 
4984
      getPhysicalOrders_result result = new getPhysicalOrders_result();
-
 
4985
      receiveBase(result, "getPhysicalOrders");
-
 
4986
      if (result.isSetSuccess()) {
-
 
4987
        return result.success;
-
 
4988
      }
-
 
4989
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
-
 
4990
    }
-
 
4991
 
4964
  }
4992
  }
4965
  public static class AsyncClient extends in.shop2020.generic.GenericService.AsyncClient implements AsyncIface {
4993
  public static class AsyncClient extends in.shop2020.generic.GenericService.AsyncClient implements AsyncIface {
4966
    public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
4994
    public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
4967
      private org.apache.thrift.async.TAsyncClientManager clientManager;
4995
      private org.apache.thrift.async.TAsyncClientManager clientManager;
4968
      private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
4996
      private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
Line 10145... Line 10173...
10145
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
10173
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
10146
        return (new Client(prot)).recv_refundRechargeOrder();
10174
        return (new Client(prot)).recv_refundRechargeOrder();
10147
      }
10175
      }
10148
    }
10176
    }
10149
 
10177
 
-
 
10178
    public void getPhysicalOrders(long fromDate, long toDate, org.apache.thrift.async.AsyncMethodCallback<getPhysicalOrders_call> resultHandler) throws org.apache.thrift.TException {
-
 
10179
      checkReady();
-
 
10180
      getPhysicalOrders_call method_call = new getPhysicalOrders_call(fromDate, toDate, resultHandler, this, ___protocolFactory, ___transport);
-
 
10181
      this.___currentMethod = method_call;
-
 
10182
      ___manager.call(method_call);
-
 
10183
    }
-
 
10184
 
-
 
10185
    public static class getPhysicalOrders_call extends org.apache.thrift.async.TAsyncMethodCall {
-
 
10186
      private long fromDate;
-
 
10187
      private long toDate;
-
 
10188
      public getPhysicalOrders_call(long fromDate, long toDate, org.apache.thrift.async.AsyncMethodCallback<getPhysicalOrders_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
-
 
10189
        super(client, protocolFactory, transport, resultHandler, false);
-
 
10190
        this.fromDate = fromDate;
-
 
10191
        this.toDate = toDate;
-
 
10192
      }
-
 
10193
 
-
 
10194
      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
-
 
10195
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPhysicalOrders", org.apache.thrift.protocol.TMessageType.CALL, 0));
-
 
10196
        getPhysicalOrders_args args = new getPhysicalOrders_args();
-
 
10197
        args.setFromDate(fromDate);
-
 
10198
        args.setToDate(toDate);
-
 
10199
        args.write(prot);
-
 
10200
        prot.writeMessageEnd();
-
 
10201
      }
-
 
10202
 
-
 
10203
      public List<Order> getResult() throws org.apache.thrift.TException {
-
 
10204
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
-
 
10205
          throw new IllegalStateException("Method call not finished!");
-
 
10206
        }
-
 
10207
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
-
 
10208
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
-
 
10209
        return (new Client(prot)).recv_getPhysicalOrders();
-
 
10210
      }
-
 
10211
    }
-
 
10212
 
10150
  }
10213
  }
10151
 
10214
 
10152
  public static class Processor<I extends Iface> extends in.shop2020.generic.GenericService.Processor implements org.apache.thrift.TProcessor {
10215
  public static class Processor<I extends Iface> extends in.shop2020.generic.GenericService.Processor implements org.apache.thrift.TProcessor {
10153
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
10216
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
10154
    public Processor(I iface) {
10217
    public Processor(I iface) {
Line 10306... Line 10369...
10306
      processMap.put("getRechargeDenominations", new getRechargeDenominations());
10369
      processMap.put("getRechargeDenominations", new getRechargeDenominations());
10307
      processMap.put("updateAvailabilityStatus", new updateAvailabilityStatus());
10370
      processMap.put("updateAvailabilityStatus", new updateAvailabilityStatus());
10308
      processMap.put("getAvailableEmiSchemes", new getAvailableEmiSchemes());
10371
      processMap.put("getAvailableEmiSchemes", new getAvailableEmiSchemes());
10309
      processMap.put("getMiscCharges", new getMiscCharges());
10372
      processMap.put("getMiscCharges", new getMiscCharges());
10310
      processMap.put("refundRechargeOrder", new refundRechargeOrder());
10373
      processMap.put("refundRechargeOrder", new refundRechargeOrder());
-
 
10374
      processMap.put("getPhysicalOrders", new getPhysicalOrders());
10311
      return processMap;
10375
      return processMap;
10312
    }
10376
    }
10313
 
10377
 
10314
    private static class createTransaction<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createTransaction_args> {
10378
    private static class createTransaction<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createTransaction_args> {
10315
      public createTransaction() {
10379
      public createTransaction() {
Line 13104... Line 13168...
13104
        }
13168
        }
13105
        return result;
13169
        return result;
13106
      }
13170
      }
13107
    }
13171
    }
13108
 
13172
 
-
 
13173
    private static class getPhysicalOrders<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPhysicalOrders_args> {
-
 
13174
      public getPhysicalOrders() {
-
 
13175
        super("getPhysicalOrders");
-
 
13176
      }
-
 
13177
 
-
 
13178
      protected getPhysicalOrders_args getEmptyArgsInstance() {
-
 
13179
        return new getPhysicalOrders_args();
-
 
13180
      }
-
 
13181
 
-
 
13182
      protected getPhysicalOrders_result getResult(I iface, getPhysicalOrders_args args) throws org.apache.thrift.TException {
-
 
13183
        getPhysicalOrders_result result = new getPhysicalOrders_result();
-
 
13184
        result.success = iface.getPhysicalOrders(args.fromDate, args.toDate);
-
 
13185
        return result;
-
 
13186
      }
-
 
13187
    }
-
 
13188
 
13109
  }
13189
  }
13110
 
13190
 
13111
  public static class createTransaction_args implements org.apache.thrift.TBase<createTransaction_args, createTransaction_args._Fields>, java.io.Serializable, Cloneable   {
13191
  public static class createTransaction_args implements org.apache.thrift.TBase<createTransaction_args, createTransaction_args._Fields>, java.io.Serializable, Cloneable   {
13112
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createTransaction_args");
13192
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createTransaction_args");
13113
 
13193
 
Line 120767... Line 120847...
120767
      }
120847
      }
120768
      first = false;
120848
      first = false;
120769
      sb.append(")");
120849
      sb.append(")");
120770
      return sb.toString();
120850
      return sb.toString();
120771
    }
120851
    }
-
 
120852
 
-
 
120853
    public void validate() throws org.apache.thrift.TException {
-
 
120854
      // check for required fields
-
 
120855
    }
-
 
120856
 
-
 
120857
    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-
 
120858
      try {
-
 
120859
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-
 
120860
      } catch (org.apache.thrift.TException te) {
-
 
120861
        throw new java.io.IOException(te);
-
 
120862
      }
-
 
120863
    }
-
 
120864
 
-
 
120865
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-
 
120866
      try {
-
 
120867
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-
 
120868
      } catch (org.apache.thrift.TException te) {
-
 
120869
        throw new java.io.IOException(te);
-
 
120870
      }
-
 
120871
    }
-
 
120872
 
-
 
120873
  }
-
 
120874
 
-
 
120875
  public static class getPhysicalOrders_args implements org.apache.thrift.TBase<getPhysicalOrders_args, getPhysicalOrders_args._Fields>, java.io.Serializable, Cloneable   {
-
 
120876
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPhysicalOrders_args");
-
 
120877
 
-
 
120878
    private static final org.apache.thrift.protocol.TField FROM_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("fromDate", org.apache.thrift.protocol.TType.I64, (short)1);
-
 
120879
    private static final org.apache.thrift.protocol.TField TO_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("toDate", org.apache.thrift.protocol.TType.I64, (short)2);
-
 
120880
 
-
 
120881
    private long fromDate; // required
-
 
120882
    private long toDate; // required
-
 
120883
 
-
 
120884
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-
 
120885
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-
 
120886
      FROM_DATE((short)1, "fromDate"),
-
 
120887
      TO_DATE((short)2, "toDate");
-
 
120888
 
-
 
120889
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
 
120890
 
-
 
120891
      static {
-
 
120892
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-
 
120893
          byName.put(field.getFieldName(), field);
-
 
120894
        }
-
 
120895
      }
-
 
120896
 
-
 
120897
      /**
-
 
120898
       * Find the _Fields constant that matches fieldId, or null if its not found.
-
 
120899
       */
-
 
120900
      public static _Fields findByThriftId(int fieldId) {
-
 
120901
        switch(fieldId) {
-
 
120902
          case 1: // FROM_DATE
-
 
120903
            return FROM_DATE;
-
 
120904
          case 2: // TO_DATE
-
 
120905
            return TO_DATE;
-
 
120906
          default:
-
 
120907
            return null;
-
 
120908
        }
-
 
120909
      }
-
 
120910
 
-
 
120911
      /**
-
 
120912
       * Find the _Fields constant that matches fieldId, throwing an exception
-
 
120913
       * if it is not found.
-
 
120914
       */
-
 
120915
      public static _Fields findByThriftIdOrThrow(int fieldId) {
-
 
120916
        _Fields fields = findByThriftId(fieldId);
-
 
120917
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-
 
120918
        return fields;
-
 
120919
      }
-
 
120920
 
-
 
120921
      /**
-
 
120922
       * Find the _Fields constant that matches name, or null if its not found.
-
 
120923
       */
-
 
120924
      public static _Fields findByName(String name) {
-
 
120925
        return byName.get(name);
-
 
120926
      }
-
 
120927
 
-
 
120928
      private final short _thriftId;
-
 
120929
      private final String _fieldName;
-
 
120930
 
-
 
120931
      _Fields(short thriftId, String fieldName) {
-
 
120932
        _thriftId = thriftId;
-
 
120933
        _fieldName = fieldName;
-
 
120934
      }
-
 
120935
 
-
 
120936
      public short getThriftFieldId() {
-
 
120937
        return _thriftId;
-
 
120938
      }
-
 
120939
 
-
 
120940
      public String getFieldName() {
-
 
120941
        return _fieldName;
-
 
120942
      }
-
 
120943
    }
-
 
120944
 
-
 
120945
    // isset id assignments
-
 
120946
    private static final int __FROMDATE_ISSET_ID = 0;
-
 
120947
    private static final int __TODATE_ISSET_ID = 1;
-
 
120948
    private BitSet __isset_bit_vector = new BitSet(2);
-
 
120949
 
-
 
120950
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-
 
120951
    static {
-
 
120952
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-
 
120953
      tmpMap.put(_Fields.FROM_DATE, new org.apache.thrift.meta_data.FieldMetaData("fromDate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
120954
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
-
 
120955
      tmpMap.put(_Fields.TO_DATE, new org.apache.thrift.meta_data.FieldMetaData("toDate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
120956
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
-
 
120957
      metaDataMap = Collections.unmodifiableMap(tmpMap);
-
 
120958
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPhysicalOrders_args.class, metaDataMap);
-
 
120959
    }
-
 
120960
 
-
 
120961
    public getPhysicalOrders_args() {
-
 
120962
    }
-
 
120963
 
-
 
120964
    public getPhysicalOrders_args(
-
 
120965
      long fromDate,
-
 
120966
      long toDate)
-
 
120967
    {
-
 
120968
      this();
-
 
120969
      this.fromDate = fromDate;
-
 
120970
      setFromDateIsSet(true);
-
 
120971
      this.toDate = toDate;
-
 
120972
      setToDateIsSet(true);
-
 
120973
    }
-
 
120974
 
-
 
120975
    /**
-
 
120976
     * Performs a deep copy on <i>other</i>.
-
 
120977
     */
-
 
120978
    public getPhysicalOrders_args(getPhysicalOrders_args other) {
-
 
120979
      __isset_bit_vector.clear();
-
 
120980
      __isset_bit_vector.or(other.__isset_bit_vector);
-
 
120981
      this.fromDate = other.fromDate;
-
 
120982
      this.toDate = other.toDate;
-
 
120983
    }
-
 
120984
 
-
 
120985
    public getPhysicalOrders_args deepCopy() {
-
 
120986
      return new getPhysicalOrders_args(this);
-
 
120987
    }
-
 
120988
 
-
 
120989
    @Override
-
 
120990
    public void clear() {
-
 
120991
      setFromDateIsSet(false);
-
 
120992
      this.fromDate = 0;
-
 
120993
      setToDateIsSet(false);
-
 
120994
      this.toDate = 0;
-
 
120995
    }
-
 
120996
 
-
 
120997
    public long getFromDate() {
-
 
120998
      return this.fromDate;
-
 
120999
    }
-
 
121000
 
-
 
121001
    public void setFromDate(long fromDate) {
-
 
121002
      this.fromDate = fromDate;
-
 
121003
      setFromDateIsSet(true);
-
 
121004
    }
-
 
121005
 
-
 
121006
    public void unsetFromDate() {
-
 
121007
      __isset_bit_vector.clear(__FROMDATE_ISSET_ID);
-
 
121008
    }
-
 
121009
 
-
 
121010
    /** Returns true if field fromDate is set (has been assigned a value) and false otherwise */
-
 
121011
    public boolean isSetFromDate() {
-
 
121012
      return __isset_bit_vector.get(__FROMDATE_ISSET_ID);
-
 
121013
    }
-
 
121014
 
-
 
121015
    public void setFromDateIsSet(boolean value) {
-
 
121016
      __isset_bit_vector.set(__FROMDATE_ISSET_ID, value);
-
 
121017
    }
-
 
121018
 
-
 
121019
    public long getToDate() {
-
 
121020
      return this.toDate;
-
 
121021
    }
-
 
121022
 
-
 
121023
    public void setToDate(long toDate) {
-
 
121024
      this.toDate = toDate;
-
 
121025
      setToDateIsSet(true);
-
 
121026
    }
-
 
121027
 
-
 
121028
    public void unsetToDate() {
-
 
121029
      __isset_bit_vector.clear(__TODATE_ISSET_ID);
-
 
121030
    }
-
 
121031
 
-
 
121032
    /** Returns true if field toDate is set (has been assigned a value) and false otherwise */
-
 
121033
    public boolean isSetToDate() {
-
 
121034
      return __isset_bit_vector.get(__TODATE_ISSET_ID);
-
 
121035
    }
-
 
121036
 
-
 
121037
    public void setToDateIsSet(boolean value) {
-
 
121038
      __isset_bit_vector.set(__TODATE_ISSET_ID, value);
-
 
121039
    }
-
 
121040
 
-
 
121041
    public void setFieldValue(_Fields field, Object value) {
-
 
121042
      switch (field) {
-
 
121043
      case FROM_DATE:
-
 
121044
        if (value == null) {
-
 
121045
          unsetFromDate();
-
 
121046
        } else {
-
 
121047
          setFromDate((Long)value);
-
 
121048
        }
-
 
121049
        break;
-
 
121050
 
-
 
121051
      case TO_DATE:
-
 
121052
        if (value == null) {
-
 
121053
          unsetToDate();
-
 
121054
        } else {
-
 
121055
          setToDate((Long)value);
-
 
121056
        }
-
 
121057
        break;
-
 
121058
 
-
 
121059
      }
-
 
121060
    }
-
 
121061
 
-
 
121062
    public Object getFieldValue(_Fields field) {
-
 
121063
      switch (field) {
-
 
121064
      case FROM_DATE:
-
 
121065
        return Long.valueOf(getFromDate());
-
 
121066
 
-
 
121067
      case TO_DATE:
-
 
121068
        return Long.valueOf(getToDate());
-
 
121069
 
-
 
121070
      }
-
 
121071
      throw new IllegalStateException();
-
 
121072
    }
-
 
121073
 
-
 
121074
    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-
 
121075
    public boolean isSet(_Fields field) {
-
 
121076
      if (field == null) {
-
 
121077
        throw new IllegalArgumentException();
-
 
121078
      }
-
 
121079
 
-
 
121080
      switch (field) {
-
 
121081
      case FROM_DATE:
-
 
121082
        return isSetFromDate();
-
 
121083
      case TO_DATE:
-
 
121084
        return isSetToDate();
-
 
121085
      }
-
 
121086
      throw new IllegalStateException();
-
 
121087
    }
-
 
121088
 
-
 
121089
    @Override
-
 
121090
    public boolean equals(Object that) {
-
 
121091
      if (that == null)
-
 
121092
        return false;
-
 
121093
      if (that instanceof getPhysicalOrders_args)
-
 
121094
        return this.equals((getPhysicalOrders_args)that);
-
 
121095
      return false;
-
 
121096
    }
-
 
121097
 
-
 
121098
    public boolean equals(getPhysicalOrders_args that) {
-
 
121099
      if (that == null)
-
 
121100
        return false;
-
 
121101
 
-
 
121102
      boolean this_present_fromDate = true;
-
 
121103
      boolean that_present_fromDate = true;
-
 
121104
      if (this_present_fromDate || that_present_fromDate) {
-
 
121105
        if (!(this_present_fromDate && that_present_fromDate))
-
 
121106
          return false;
-
 
121107
        if (this.fromDate != that.fromDate)
-
 
121108
          return false;
-
 
121109
      }
-
 
121110
 
-
 
121111
      boolean this_present_toDate = true;
-
 
121112
      boolean that_present_toDate = true;
-
 
121113
      if (this_present_toDate || that_present_toDate) {
-
 
121114
        if (!(this_present_toDate && that_present_toDate))
-
 
121115
          return false;
-
 
121116
        if (this.toDate != that.toDate)
-
 
121117
          return false;
-
 
121118
      }
-
 
121119
 
-
 
121120
      return true;
-
 
121121
    }
-
 
121122
 
-
 
121123
    @Override
-
 
121124
    public int hashCode() {
-
 
121125
      return 0;
-
 
121126
    }
-
 
121127
 
-
 
121128
    public int compareTo(getPhysicalOrders_args other) {
-
 
121129
      if (!getClass().equals(other.getClass())) {
-
 
121130
        return getClass().getName().compareTo(other.getClass().getName());
-
 
121131
      }
-
 
121132
 
-
 
121133
      int lastComparison = 0;
-
 
121134
      getPhysicalOrders_args typedOther = (getPhysicalOrders_args)other;
-
 
121135
 
-
 
121136
      lastComparison = Boolean.valueOf(isSetFromDate()).compareTo(typedOther.isSetFromDate());
-
 
121137
      if (lastComparison != 0) {
-
 
121138
        return lastComparison;
-
 
121139
      }
-
 
121140
      if (isSetFromDate()) {
-
 
121141
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fromDate, typedOther.fromDate);
-
 
121142
        if (lastComparison != 0) {
-
 
121143
          return lastComparison;
-
 
121144
        }
-
 
121145
      }
-
 
121146
      lastComparison = Boolean.valueOf(isSetToDate()).compareTo(typedOther.isSetToDate());
-
 
121147
      if (lastComparison != 0) {
-
 
121148
        return lastComparison;
-
 
121149
      }
-
 
121150
      if (isSetToDate()) {
-
 
121151
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.toDate, typedOther.toDate);
-
 
121152
        if (lastComparison != 0) {
-
 
121153
          return lastComparison;
-
 
121154
        }
-
 
121155
      }
-
 
121156
      return 0;
-
 
121157
    }
-
 
121158
 
-
 
121159
    public _Fields fieldForId(int fieldId) {
-
 
121160
      return _Fields.findByThriftId(fieldId);
-
 
121161
    }
-
 
121162
 
-
 
121163
    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-
 
121164
      org.apache.thrift.protocol.TField field;
-
 
121165
      iprot.readStructBegin();
-
 
121166
      while (true)
-
 
121167
      {
-
 
121168
        field = iprot.readFieldBegin();
-
 
121169
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
-
 
121170
          break;
-
 
121171
        }
-
 
121172
        switch (field.id) {
-
 
121173
          case 1: // FROM_DATE
-
 
121174
            if (field.type == org.apache.thrift.protocol.TType.I64) {
-
 
121175
              this.fromDate = iprot.readI64();
-
 
121176
              setFromDateIsSet(true);
-
 
121177
            } else { 
-
 
121178
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
121179
            }
-
 
121180
            break;
-
 
121181
          case 2: // TO_DATE
-
 
121182
            if (field.type == org.apache.thrift.protocol.TType.I64) {
-
 
121183
              this.toDate = iprot.readI64();
-
 
121184
              setToDateIsSet(true);
-
 
121185
            } else { 
-
 
121186
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
121187
            }
-
 
121188
            break;
-
 
121189
          default:
-
 
121190
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
121191
        }
-
 
121192
        iprot.readFieldEnd();
-
 
121193
      }
-
 
121194
      iprot.readStructEnd();
-
 
121195
      validate();
-
 
121196
    }
-
 
121197
 
-
 
121198
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-
 
121199
      validate();
-
 
121200
 
-
 
121201
      oprot.writeStructBegin(STRUCT_DESC);
-
 
121202
      oprot.writeFieldBegin(FROM_DATE_FIELD_DESC);
-
 
121203
      oprot.writeI64(this.fromDate);
-
 
121204
      oprot.writeFieldEnd();
-
 
121205
      oprot.writeFieldBegin(TO_DATE_FIELD_DESC);
-
 
121206
      oprot.writeI64(this.toDate);
-
 
121207
      oprot.writeFieldEnd();
-
 
121208
      oprot.writeFieldStop();
-
 
121209
      oprot.writeStructEnd();
-
 
121210
    }
-
 
121211
 
-
 
121212
    @Override
-
 
121213
    public String toString() {
-
 
121214
      StringBuilder sb = new StringBuilder("getPhysicalOrders_args(");
-
 
121215
      boolean first = true;
-
 
121216
 
-
 
121217
      sb.append("fromDate:");
-
 
121218
      sb.append(this.fromDate);
-
 
121219
      first = false;
-
 
121220
      if (!first) sb.append(", ");
-
 
121221
      sb.append("toDate:");
-
 
121222
      sb.append(this.toDate);
-
 
121223
      first = false;
-
 
121224
      sb.append(")");
-
 
121225
      return sb.toString();
-
 
121226
    }
-
 
121227
 
-
 
121228
    public void validate() throws org.apache.thrift.TException {
-
 
121229
      // check for required fields
-
 
121230
    }
-
 
121231
 
-
 
121232
    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-
 
121233
      try {
-
 
121234
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-
 
121235
      } catch (org.apache.thrift.TException te) {
-
 
121236
        throw new java.io.IOException(te);
-
 
121237
      }
-
 
121238
    }
-
 
121239
 
-
 
121240
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-
 
121241
      try {
-
 
121242
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
-
 
121243
        __isset_bit_vector = new BitSet(1);
-
 
121244
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-
 
121245
      } catch (org.apache.thrift.TException te) {
-
 
121246
        throw new java.io.IOException(te);
-
 
121247
      }
-
 
121248
    }
-
 
121249
 
-
 
121250
  }
-
 
121251
 
-
 
121252
  public static class getPhysicalOrders_result implements org.apache.thrift.TBase<getPhysicalOrders_result, getPhysicalOrders_result._Fields>, java.io.Serializable, Cloneable   {
-
 
121253
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPhysicalOrders_result");
-
 
121254
 
-
 
121255
    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
-
 
121256
 
-
 
121257
    private List<Order> success; // required
-
 
121258
 
-
 
121259
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-
 
121260
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-
 
121261
      SUCCESS((short)0, "success");
-
 
121262
 
-
 
121263
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
 
121264
 
-
 
121265
      static {
-
 
121266
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-
 
121267
          byName.put(field.getFieldName(), field);
-
 
121268
        }
-
 
121269
      }
-
 
121270
 
-
 
121271
      /**
-
 
121272
       * Find the _Fields constant that matches fieldId, or null if its not found.
-
 
121273
       */
-
 
121274
      public static _Fields findByThriftId(int fieldId) {
-
 
121275
        switch(fieldId) {
-
 
121276
          case 0: // SUCCESS
-
 
121277
            return SUCCESS;
-
 
121278
          default:
-
 
121279
            return null;
-
 
121280
        }
-
 
121281
      }
-
 
121282
 
-
 
121283
      /**
-
 
121284
       * Find the _Fields constant that matches fieldId, throwing an exception
-
 
121285
       * if it is not found.
-
 
121286
       */
-
 
121287
      public static _Fields findByThriftIdOrThrow(int fieldId) {
-
 
121288
        _Fields fields = findByThriftId(fieldId);
-
 
121289
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-
 
121290
        return fields;
-
 
121291
      }
-
 
121292
 
-
 
121293
      /**
-
 
121294
       * Find the _Fields constant that matches name, or null if its not found.
-
 
121295
       */
-
 
121296
      public static _Fields findByName(String name) {
-
 
121297
        return byName.get(name);
-
 
121298
      }
-
 
121299
 
-
 
121300
      private final short _thriftId;
-
 
121301
      private final String _fieldName;
-
 
121302
 
-
 
121303
      _Fields(short thriftId, String fieldName) {
-
 
121304
        _thriftId = thriftId;
-
 
121305
        _fieldName = fieldName;
-
 
121306
      }
-
 
121307
 
-
 
121308
      public short getThriftFieldId() {
-
 
121309
        return _thriftId;
-
 
121310
      }
-
 
121311
 
-
 
121312
      public String getFieldName() {
-
 
121313
        return _fieldName;
-
 
121314
      }
-
 
121315
    }
-
 
121316
 
-
 
121317
    // isset id assignments
-
 
121318
 
-
 
121319
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-
 
121320
    static {
-
 
121321
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-
 
121322
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
121323
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
-
 
121324
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Order.class))));
-
 
121325
      metaDataMap = Collections.unmodifiableMap(tmpMap);
-
 
121326
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPhysicalOrders_result.class, metaDataMap);
-
 
121327
    }
-
 
121328
 
-
 
121329
    public getPhysicalOrders_result() {
-
 
121330
    }
-
 
121331
 
-
 
121332
    public getPhysicalOrders_result(
-
 
121333
      List<Order> success)
-
 
121334
    {
-
 
121335
      this();
-
 
121336
      this.success = success;
-
 
121337
    }
-
 
121338
 
-
 
121339
    /**
-
 
121340
     * Performs a deep copy on <i>other</i>.
-
 
121341
     */
-
 
121342
    public getPhysicalOrders_result(getPhysicalOrders_result other) {
-
 
121343
      if (other.isSetSuccess()) {
-
 
121344
        List<Order> __this__success = new ArrayList<Order>();
-
 
121345
        for (Order other_element : other.success) {
-
 
121346
          __this__success.add(new Order(other_element));
-
 
121347
        }
-
 
121348
        this.success = __this__success;
-
 
121349
      }
-
 
121350
    }
-
 
121351
 
-
 
121352
    public getPhysicalOrders_result deepCopy() {
-
 
121353
      return new getPhysicalOrders_result(this);
-
 
121354
    }
-
 
121355
 
-
 
121356
    @Override
-
 
121357
    public void clear() {
-
 
121358
      this.success = null;
-
 
121359
    }
-
 
121360
 
-
 
121361
    public int getSuccessSize() {
-
 
121362
      return (this.success == null) ? 0 : this.success.size();
-
 
121363
    }
-
 
121364
 
-
 
121365
    public java.util.Iterator<Order> getSuccessIterator() {
-
 
121366
      return (this.success == null) ? null : this.success.iterator();
-
 
121367
    }
-
 
121368
 
-
 
121369
    public void addToSuccess(Order elem) {
-
 
121370
      if (this.success == null) {
-
 
121371
        this.success = new ArrayList<Order>();
-
 
121372
      }
-
 
121373
      this.success.add(elem);
-
 
121374
    }
-
 
121375
 
-
 
121376
    public List<Order> getSuccess() {
-
 
121377
      return this.success;
-
 
121378
    }
-
 
121379
 
-
 
121380
    public void setSuccess(List<Order> success) {
-
 
121381
      this.success = success;
-
 
121382
    }
-
 
121383
 
-
 
121384
    public void unsetSuccess() {
-
 
121385
      this.success = null;
-
 
121386
    }
-
 
121387
 
-
 
121388
    /** Returns true if field success is set (has been assigned a value) and false otherwise */
-
 
121389
    public boolean isSetSuccess() {
-
 
121390
      return this.success != null;
-
 
121391
    }
-
 
121392
 
-
 
121393
    public void setSuccessIsSet(boolean value) {
-
 
121394
      if (!value) {
-
 
121395
        this.success = null;
-
 
121396
      }
-
 
121397
    }
-
 
121398
 
-
 
121399
    public void setFieldValue(_Fields field, Object value) {
-
 
121400
      switch (field) {
-
 
121401
      case SUCCESS:
-
 
121402
        if (value == null) {
-
 
121403
          unsetSuccess();
-
 
121404
        } else {
-
 
121405
          setSuccess((List<Order>)value);
-
 
121406
        }
-
 
121407
        break;
-
 
121408
 
-
 
121409
      }
-
 
121410
    }
-
 
121411
 
-
 
121412
    public Object getFieldValue(_Fields field) {
-
 
121413
      switch (field) {
-
 
121414
      case SUCCESS:
-
 
121415
        return getSuccess();
-
 
121416
 
-
 
121417
      }
-
 
121418
      throw new IllegalStateException();
-
 
121419
    }
-
 
121420
 
-
 
121421
    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-
 
121422
    public boolean isSet(_Fields field) {
-
 
121423
      if (field == null) {
-
 
121424
        throw new IllegalArgumentException();
-
 
121425
      }
-
 
121426
 
-
 
121427
      switch (field) {
-
 
121428
      case SUCCESS:
-
 
121429
        return isSetSuccess();
-
 
121430
      }
-
 
121431
      throw new IllegalStateException();
-
 
121432
    }
-
 
121433
 
-
 
121434
    @Override
-
 
121435
    public boolean equals(Object that) {
-
 
121436
      if (that == null)
-
 
121437
        return false;
-
 
121438
      if (that instanceof getPhysicalOrders_result)
-
 
121439
        return this.equals((getPhysicalOrders_result)that);
-
 
121440
      return false;
-
 
121441
    }
-
 
121442
 
-
 
121443
    public boolean equals(getPhysicalOrders_result that) {
-
 
121444
      if (that == null)
-
 
121445
        return false;
-
 
121446
 
-
 
121447
      boolean this_present_success = true && this.isSetSuccess();
-
 
121448
      boolean that_present_success = true && that.isSetSuccess();
-
 
121449
      if (this_present_success || that_present_success) {
-
 
121450
        if (!(this_present_success && that_present_success))
-
 
121451
          return false;
-
 
121452
        if (!this.success.equals(that.success))
-
 
121453
          return false;
-
 
121454
      }
-
 
121455
 
-
 
121456
      return true;
-
 
121457
    }
-
 
121458
 
-
 
121459
    @Override
-
 
121460
    public int hashCode() {
-
 
121461
      return 0;
-
 
121462
    }
-
 
121463
 
-
 
121464
    public int compareTo(getPhysicalOrders_result other) {
-
 
121465
      if (!getClass().equals(other.getClass())) {
-
 
121466
        return getClass().getName().compareTo(other.getClass().getName());
-
 
121467
      }
-
 
121468
 
-
 
121469
      int lastComparison = 0;
-
 
121470
      getPhysicalOrders_result typedOther = (getPhysicalOrders_result)other;
-
 
121471
 
-
 
121472
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
-
 
121473
      if (lastComparison != 0) {
-
 
121474
        return lastComparison;
-
 
121475
      }
-
 
121476
      if (isSetSuccess()) {
-
 
121477
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
-
 
121478
        if (lastComparison != 0) {
-
 
121479
          return lastComparison;
-
 
121480
        }
-
 
121481
      }
-
 
121482
      return 0;
-
 
121483
    }
-
 
121484
 
-
 
121485
    public _Fields fieldForId(int fieldId) {
-
 
121486
      return _Fields.findByThriftId(fieldId);
-
 
121487
    }
-
 
121488
 
-
 
121489
    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-
 
121490
      org.apache.thrift.protocol.TField field;
-
 
121491
      iprot.readStructBegin();
-
 
121492
      while (true)
-
 
121493
      {
-
 
121494
        field = iprot.readFieldBegin();
-
 
121495
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
-
 
121496
          break;
-
 
121497
        }
-
 
121498
        switch (field.id) {
-
 
121499
          case 0: // SUCCESS
-
 
121500
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
-
 
121501
              {
-
 
121502
                org.apache.thrift.protocol.TList _list410 = iprot.readListBegin();
-
 
121503
                this.success = new ArrayList<Order>(_list410.size);
-
 
121504
                for (int _i411 = 0; _i411 < _list410.size; ++_i411)
-
 
121505
                {
-
 
121506
                  Order _elem412; // required
-
 
121507
                  _elem412 = new Order();
-
 
121508
                  _elem412.read(iprot);
-
 
121509
                  this.success.add(_elem412);
-
 
121510
                }
-
 
121511
                iprot.readListEnd();
-
 
121512
              }
-
 
121513
            } else { 
-
 
121514
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
121515
            }
-
 
121516
            break;
-
 
121517
          default:
-
 
121518
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
121519
        }
-
 
121520
        iprot.readFieldEnd();
-
 
121521
      }
-
 
121522
      iprot.readStructEnd();
-
 
121523
      validate();
-
 
121524
    }
-
 
121525
 
-
 
121526
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-
 
121527
      oprot.writeStructBegin(STRUCT_DESC);
-
 
121528
 
-
 
121529
      if (this.isSetSuccess()) {
-
 
121530
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-
 
121531
        {
-
 
121532
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-
 
121533
          for (Order _iter413 : this.success)
-
 
121534
          {
-
 
121535
            _iter413.write(oprot);
-
 
121536
          }
-
 
121537
          oprot.writeListEnd();
-
 
121538
        }
-
 
121539
        oprot.writeFieldEnd();
-
 
121540
      }
-
 
121541
      oprot.writeFieldStop();
-
 
121542
      oprot.writeStructEnd();
-
 
121543
    }
-
 
121544
 
-
 
121545
    @Override
-
 
121546
    public String toString() {
-
 
121547
      StringBuilder sb = new StringBuilder("getPhysicalOrders_result(");
-
 
121548
      boolean first = true;
-
 
121549
 
-
 
121550
      sb.append("success:");
-
 
121551
      if (this.success == null) {
-
 
121552
        sb.append("null");
-
 
121553
      } else {
-
 
121554
        sb.append(this.success);
-
 
121555
      }
-
 
121556
      first = false;
-
 
121557
      sb.append(")");
-
 
121558
      return sb.toString();
-
 
121559
    }
120772
 
121560
 
120773
    public void validate() throws org.apache.thrift.TException {
121561
    public void validate() throws org.apache.thrift.TException {
120774
      // check for required fields
121562
      // check for required fields
120775
    }
121563
    }
120776
 
121564