// Automatically generated by the Thrifty compiler; do not edit!
// Generated on: 2020-11-05T09:22:38.165Z
// Source: J:\facelog\facelog-service\IFaceLog.thrift at 280:1
package net.gdface.facelog.client.thrift;

import com.microsoft.thrifty.TType;
import com.microsoft.thrifty.ThriftException;
import com.microsoft.thrifty.protocol.FieldMetadata;
import com.microsoft.thrifty.protocol.ListMetadata;
import com.microsoft.thrifty.protocol.MapMetadata;
import com.microsoft.thrifty.protocol.MessageMetadata;
import com.microsoft.thrifty.protocol.Protocol;
import com.microsoft.thrifty.service.AsyncClientBase;
import com.microsoft.thrifty.service.MethodCall;
import com.microsoft.thrifty.service.ServiceMethodCallback;
import com.microsoft.thrifty.service.TMessageType;
import com.microsoft.thrifty.util.ProtocolUtil;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Generated;
import okio.ByteString;

@Generated(
    value = "com.microsoft.thrifty.gen.ThriftyCodeGenerator",
    comments = "https://github.com/microsoft/thrifty"
)
public class IFaceLogClient extends AsyncClientBase implements IFaceLog {
  public IFaceLogClient(Protocol protocol, AsyncClientBase.Listener listener) {
    super(protocol, listener);
  }

  @Override
  public void addErrorLog(ErrorLogBean errorLogBean, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new AddErrorLogCall(errorLogBean, token, callback));
  }

  @Override
  public void addFeature(ByteString feature, String featureVersion, Integer personId,
      List<FaceBean> faecBeans, String removed, Token token,
      ServiceMethodCallback<FeatureBean> callback) {
    this.enqueue(new AddFeatureCall(feature, featureVersion, personId, faecBeans, removed, token, callback));
  }

  @Override
  public void addFeatureMulti(ByteString feature, String featureVersion, Integer personId,
      List<ByteString> photos, List<FaceBean> faces, String removed, Token token,
      ServiceMethodCallback<FeatureBean> callback) {
    this.enqueue(new AddFeatureMultiCall(feature, featureVersion, personId, photos, faces, removed, token, callback));
  }

  @Override
  public void addFeatureWithImage(ByteString feature, String featureVersion, Integer personId,
      Boolean asIdPhotoIfAbsent, ByteString featurePhoto, FaceBean faceBean, String removed,
      Token token, ServiceMethodCallback<FeatureBean> callback) {
    this.enqueue(new AddFeatureWithImageCall(feature, featureVersion, personId, asIdPhotoIfAbsent, featurePhoto, faceBean, removed, token, callback));
  }

  @Override
  public void addImage(ByteString imageData, Integer deviceId, FaceBean faceBean, Integer personId,
      Token token, ServiceMethodCallback<ImageBean> callback) {
    this.enqueue(new AddImageCall(imageData, deviceId, faceBean, personId, token, callback));
  }

  @Override
  public void addLog(LogBean logBean, Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new AddLogCall(logBean, token, callback));
  }

  @Override
  public void addLogFull(LogBean logBean, FaceBean faceBean, ByteString featureImage, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new AddLogFullCall(logBean, faceBean, featureImage, token, callback));
  }

  @Override
  public void addLogWithFaceImage(LogBean logBean, ByteString faceImage, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new AddLogWithFaceImageCall(logBean, faceImage, token, callback));
  }

  @Override
  public void addLogs(List<LogBean> beans, Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new AddLogsCall(beans, token, callback));
  }

  @Override
  public void addLogsFull(List<LogBean> logBeans, List<FaceBean> faceBeans,
      List<ByteString> featureImages, Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new AddLogsFullCall(logBeans, faceBeans, featureImages, token, callback));
  }

  @Override
  public void addLogsWithFaceImage(List<LogBean> logBeans, List<ByteString> faceImages, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new AddLogsWithFaceImageCall(logBeans, faceImages, token, callback));
  }

  @Override
  public void applyAckChannel(Token token, ServiceMethodCallback<String> callback) {
    this.enqueue(new ApplyAckChannelCall(token, callback));
  }

  @Override
  public void applyAckChannelWithDuration(Integer duration, Token token,
      ServiceMethodCallback<String> callback) {
    this.enqueue(new ApplyAckChannelWithDurationCall(duration, token, callback));
  }

  @Override
  public void applyCmdSn(Token token, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new ApplyCmdSnCall(token, callback));
  }

  @Override
  public void applyPersonToken(Integer personId, String password, Boolean isMd5,
      ServiceMethodCallback<Token> callback) {
    this.enqueue(new ApplyPersonTokenCall(personId, password, isMd5, callback));
  }

  @Override
  public void applyRootToken(String password, Boolean isMd5,
      ServiceMethodCallback<Token> callback) {
    this.enqueue(new ApplyRootTokenCall(password, isMd5, callback));
  }

  @Override
  public void applyUserToken(Integer userid, String password, Boolean isMd5,
      ServiceMethodCallback<Token> callback) {
    this.enqueue(new ApplyUserTokenCall(userid, password, isMd5, callback));
  }

  @Override
  public void bindBorder(Integer personGroupId, Integer deviceGroupId, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new BindBorderCall(personGroupId, deviceGroupId, token, callback));
  }

  @Override
  public void childListForDeviceGroup(Integer deviceGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new ChildListForDeviceGroupCall(deviceGroupId, callback));
  }

  @Override
  public void childListForPersonGroup(Integer personGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new ChildListForPersonGroupCall(personGroupId, callback));
  }

  @Override
  public void countDeviceByWhere(String where, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountDeviceByWhereCall(where, callback));
  }

  @Override
  public void countDeviceGroupByWhere(String where, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountDeviceGroupByWhereCall(where, callback));
  }

  @Override
  public void countErrorLogByWhere(String where, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountErrorLogByWhereCall(where, callback));
  }

  @Override
  public void countLogByWhere(String where, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountLogByWhereCall(where, callback));
  }

  @Override
  public void countLogLightByVerifyTime(Long timestamp, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountLogLightByVerifyTimeCall(timestamp, callback));
  }

  @Override
  public void countLogLightByVerifyTimeTimestr(String timestamp,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountLogLightByVerifyTimeTimestrCall(timestamp, callback));
  }

  @Override
  public void countLogLightByWhere(String where, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountLogLightByWhereCall(where, callback));
  }

  @Override
  public void countPersonByWhere(String where, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountPersonByWhereCall(where, callback));
  }

  @Override
  public void countPersonGroupByWhere(String where, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new CountPersonGroupByWhereCall(where, callback));
  }

  @Override
  public void countPersonLog(Integer personId, Long startDate, Long endDate,
      ServiceMethodCallback<Map<String, Integer>> callback) {
    this.enqueue(new CountPersonLogCall(personId, startDate, endDate, callback));
  }

  @Override
  public void countPersonLogTimeStr(Integer personId, String startDate, String endDate,
      ServiceMethodCallback<Map<String, Integer>> callback) {
    this.enqueue(new CountPersonLogTimeStrCall(personId, startDate, endDate, callback));
  }

  @Override
  public void createTempPwd(Integer targetId, TmpPwdTargetType targetType, String expiryDate,
      Token token, ServiceMethodCallback<String> callback) {
    this.enqueue(new CreateTempPwdCall(targetId, targetType, expiryDate, token, callback));
  }

  @Override
  public void createTempPwdWithDuration(Integer targetId, TmpPwdTargetType targetType,
      Integer duration, Token token, ServiceMethodCallback<String> callback) {
    this.enqueue(new CreateTempPwdWithDurationCall(targetId, targetType, duration, token, callback));
  }

  @Override
  public void deleteAllFeaturesByPersonId(Integer personId, Boolean deleteImage, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeleteAllFeaturesByPersonIdCall(personId, deleteImage, token, callback));
  }

  @Override
  public void deleteDevice(Integer id, Token token, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new DeleteDeviceCall(id, token, callback));
  }

  @Override
  public void deleteDeviceByMac(String mac, Token token, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new DeleteDeviceByMacCall(mac, token, callback));
  }

  @Override
  public void deleteDeviceGroup(Integer deviceGroupId, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeleteDeviceGroupCall(deviceGroupId, token, callback));
  }

  @Override
  public void deleteErrorLogByWhere(String where, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeleteErrorLogByWhereCall(where, token, callback));
  }

  @Override
  public void deleteFeature(String featureMd5, Boolean deleteImage, Token token,
      ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new DeleteFeatureCall(featureMd5, deleteImage, token, callback));
  }

  @Override
  public void deleteGroupPermitOnDeviceGroup(Integer deviceGroupId, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeleteGroupPermitOnDeviceGroupCall(deviceGroupId, token, callback));
  }

  @Override
  public void deleteImage(String imageMd5, Token token, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeleteImageCall(imageMd5, token, callback));
  }

  @Override
  public void deleteLogByWhere(String where, Token token, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeleteLogByWhereCall(where, token, callback));
  }

  @Override
  public void deletePermitById(Integer deviceGroupId, Integer personGroupId, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeletePermitByIdCall(deviceGroupId, personGroupId, token, callback));
  }

  @Override
  public void deletePerson(Integer personId, Token token, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeletePersonCall(personId, token, callback));
  }

  @Override
  public void deletePersonByPapersNum(String papersNum, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeletePersonByPapersNumCall(papersNum, token, callback));
  }

  @Override
  public void deletePersonGroup(Integer personGroupId, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeletePersonGroupCall(personGroupId, token, callback));
  }

  @Override
  public void deletePersonGroupPermit(Integer personGroupId, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeletePersonGroupPermitCall(personGroupId, token, callback));
  }

  @Override
  public void deletePersons(List<Integer> personIdList, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeletePersonsCall(personIdList, token, callback));
  }

  @Override
  public void deletePersonsByPapersNum(List<String> papersNumlist, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new DeletePersonsByPapersNumCall(papersNumlist, token, callback));
  }

  @Override
  public void disablePerson(Integer personId, Integer moveToGroupId, Boolean deletePhoto,
      Boolean deleteFeature, Boolean deleteLog, Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new DisablePersonCall(personId, moveToGroupId, deletePhoto, deleteFeature, deleteLog, token, callback));
  }

  @Override
  public void disablePersonList(List<Integer> personIdList, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new DisablePersonListCall(personIdList, token, callback));
  }

  @Override
  public void existsDevice(Integer id, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new ExistsDeviceCall(id, callback));
  }

  @Override
  public void existsFeature(String md5, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new ExistsFeatureCall(md5, callback));
  }

  @Override
  public void existsImage(String md5, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new ExistsImageCall(md5, callback));
  }

  @Override
  public void existsPerson(Integer persionId, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new ExistsPersonCall(persionId, callback));
  }

  @Override
  public void faceRecognizePersonPermitted(ByteString imageData, Double threshold, Integer deviceId,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new FaceRecognizePersonPermittedCall(imageData, threshold, deviceId, callback));
  }

  @Override
  public void getDevice(Integer deviceId, ServiceMethodCallback<DeviceBean> callback) {
    this.enqueue(new GetDeviceCall(deviceId, callback));
  }

  @Override
  public void getDeviceByMac(String mac, ServiceMethodCallback<DeviceBean> callback) {
    this.enqueue(new GetDeviceByMacCall(mac, callback));
  }

  @Override
  public void getDeviceGroup(Integer deviceGroupId,
      ServiceMethodCallback<DeviceGroupBean> callback) {
    this.enqueue(new GetDeviceGroupCall(deviceGroupId, callback));
  }

  @Override
  public void getDeviceGroups(List<Integer> groupIdList,
      ServiceMethodCallback<List<DeviceGroupBean>> callback) {
    this.enqueue(new GetDeviceGroupsCall(groupIdList, callback));
  }

  @Override
  public void getDeviceGroupsBelongs(Integer deviceId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetDeviceGroupsBelongsCall(deviceId, callback));
  }

  @Override
  public void getDeviceGroupsPermit(Integer personGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetDeviceGroupsPermitCall(personGroupId, callback));
  }

  @Override
  public void getDeviceGroupsPermittedBy(Integer personGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetDeviceGroupsPermittedByCall(personGroupId, callback));
  }

  @Override
  public void getDeviceIdOfFeature(String featureMd5, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new GetDeviceIdOfFeatureCall(featureMd5, callback));
  }

  @Override
  public void getDevices(List<Integer> idList, ServiceMethodCallback<List<DeviceBean>> callback) {
    this.enqueue(new GetDevicesCall(idList, callback));
  }

  @Override
  public void getDevicesOfGroup(Integer deviceGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetDevicesOfGroupCall(deviceGroupId, callback));
  }

  @Override
  public void getFace(Integer faceId, ServiceMethodCallback<FaceBean> callback) {
    this.enqueue(new GetFaceCall(faceId, callback));
  }

  @Override
  public void getFaceApiParameters(Token token,
      ServiceMethodCallback<Map<String, String>> callback) {
    this.enqueue(new GetFaceApiParametersCall(token, callback));
  }

  @Override
  public void getFacesOfFeature(String featureMd5, ServiceMethodCallback<List<FaceBean>> callback) {
    this.enqueue(new GetFacesOfFeatureCall(featureMd5, callback));
  }

  @Override
  public void getFacesOfImage(String imageMd5, ServiceMethodCallback<List<FaceBean>> callback) {
    this.enqueue(new GetFacesOfImageCall(imageMd5, callback));
  }

  @Override
  public void getFeature(String md5, ServiceMethodCallback<FeatureBean> callback) {
    this.enqueue(new GetFeatureCall(md5, callback));
  }

  @Override
  public void getFeatureBytes(String md5, ServiceMethodCallback<ByteString> callback) {
    this.enqueue(new GetFeatureBytesCall(md5, callback));
  }

  @Override
  public void getFeatureBytesList(List<String> md5List, Boolean truncation,
      ServiceMethodCallback<List<ByteString>> callback) {
    this.enqueue(new GetFeatureBytesListCall(md5List, truncation, callback));
  }

  @Override
  public void getFeatureBytesTruncation(String md5, Boolean truncation,
      ServiceMethodCallback<ByteString> callback) {
    this.enqueue(new GetFeatureBytesTruncationCall(md5, truncation, callback));
  }

  @Override
  public void getFeatures(List<String> md5List, ServiceMethodCallback<List<FeatureBean>> callback) {
    this.enqueue(new GetFeaturesCall(md5List, callback));
  }

  @Override
  public void getFeaturesByPersonIdAndSdkVersion(Integer personId, String sdkVersion,
      ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new GetFeaturesByPersonIdAndSdkVersionCall(personId, sdkVersion, callback));
  }

  @Override
  public void getFeaturesOfImage(String imageMd5, ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new GetFeaturesOfImageCall(imageMd5, callback));
  }

  @Override
  public void getFeaturesOfPerson(Integer personId, ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new GetFeaturesOfPersonCall(personId, callback));
  }

  @Override
  public void getFeaturesPermittedOnDevice(Integer deviceId, Boolean ignoreSchedule,
      String sdkVersion, List<String> excludeFeatureIds, Long timestamp,
      ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new GetFeaturesPermittedOnDeviceCall(deviceId, ignoreSchedule, sdkVersion, excludeFeatureIds, timestamp, callback));
  }

  @Override
  public void getGroupPermit(Integer deviceId, Integer personGroupId,
      ServiceMethodCallback<PermitBean> callback) {
    this.enqueue(new GetGroupPermitCall(deviceId, personGroupId, callback));
  }

  @Override
  public void getGroupPermitOnDeviceGroup(Integer deviceGroupId, Integer personGroupId,
      ServiceMethodCallback<PermitBean> callback) {
    this.enqueue(new GetGroupPermitOnDeviceGroupCall(deviceGroupId, personGroupId, callback));
  }

  @Override
  public void getGroupPermits(Integer deviceId, List<Integer> personGroupIdList,
      ServiceMethodCallback<List<PermitBean>> callback) {
    this.enqueue(new GetGroupPermitsCall(deviceId, personGroupIdList, callback));
  }

  @Override
  public void getImage(String imageMD5, ServiceMethodCallback<ImageBean> callback) {
    this.enqueue(new GetImageCall(imageMD5, callback));
  }

  @Override
  public void getImageBytes(String imageMD5, ServiceMethodCallback<ByteString> callback) {
    this.enqueue(new GetImageBytesCall(imageMD5, callback));
  }

  @Override
  public void getImageBytesRef(String primaryKey, String refType,
      ServiceMethodCallback<ByteString> callback) {
    this.enqueue(new GetImageBytesRefCall(primaryKey, refType, callback));
  }

  @Override
  public void getImageRef(String primaryKey, String refType,
      ServiceMethodCallback<ImageBean> callback) {
    this.enqueue(new GetImageRefCall(primaryKey, refType, callback));
  }

  @Override
  public void getImagesAssociatedByFeature(String featureMd5,
      ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new GetImagesAssociatedByFeatureCall(featureMd5, callback));
  }

  @Override
  public void getLogBeansByPersonId(Integer personId,
      ServiceMethodCallback<List<LogBean>> callback) {
    this.enqueue(new GetLogBeansByPersonIdCall(personId, callback));
  }

  @Override
  public void getMessageQueueParameters(Token token,
      ServiceMethodCallback<Map<MQParam, String>> callback) {
    this.enqueue(new GetMessageQueueParametersCall(token, callback));
  }

  @Override
  public void getPerson(Integer personId, ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new GetPersonCall(personId, callback));
  }

  @Override
  public void getPersonByMobilePhone(String mobilePhone,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new GetPersonByMobilePhoneCall(mobilePhone, callback));
  }

  @Override
  public void getPersonByMobilePhoneReal(String mobilePhone, Token token,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new GetPersonByMobilePhoneRealCall(mobilePhone, token, callback));
  }

  @Override
  public void getPersonByPapersNum(String papersNum, ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new GetPersonByPapersNumCall(papersNum, callback));
  }

  @Override
  public void getPersonByPapersNumReal(String papersNum, Token token,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new GetPersonByPapersNumRealCall(papersNum, token, callback));
  }

  @Override
  public void getPersonGroup(Integer personGroupId,
      ServiceMethodCallback<PersonGroupBean> callback) {
    this.enqueue(new GetPersonGroupCall(personGroupId, callback));
  }

  @Override
  public void getPersonGroups(List<Integer> groupIdList,
      ServiceMethodCallback<List<PersonGroupBean>> callback) {
    this.enqueue(new GetPersonGroupsCall(groupIdList, callback));
  }

  @Override
  public void getPersonGroupsBelongs(Integer personId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetPersonGroupsBelongsCall(personId, callback));
  }

  @Override
  public void getPersonGroupsPermittedBy(Integer deviceGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetPersonGroupsPermittedByCall(deviceGroupId, callback));
  }

  @Override
  public void getPersonPermit(Integer deviceId, Integer personId,
      ServiceMethodCallback<PermitBean> callback) {
    this.enqueue(new GetPersonPermitCall(deviceId, personId, callback));
  }

  @Override
  public void getPersonPermits(Integer deviceId, List<Integer> personIdList,
      ServiceMethodCallback<List<PermitBean>> callback) {
    this.enqueue(new GetPersonPermitsCall(deviceId, personIdList, callback));
  }

  @Override
  public void getPersonReal(Integer personId, Token token,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new GetPersonRealCall(personId, token, callback));
  }

  @Override
  public void getPersons(List<Integer> idList, ServiceMethodCallback<List<PersonBean>> callback) {
    this.enqueue(new GetPersonsCall(idList, callback));
  }

  @Override
  public void getPersonsOfGroup(Integer personGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetPersonsOfGroupCall(personGroupId, callback));
  }

  @Override
  public void getPersonsPermittedOnDevice(Integer deviceId, Boolean ignoreSchedule,
      List<Integer> excludePersonIds, Long timestamp,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetPersonsPermittedOnDeviceCall(deviceId, ignoreSchedule, excludePersonIds, timestamp, callback));
  }

  @Override
  public void getPersonsReal(List<Integer> idList, Token token,
      ServiceMethodCallback<List<PersonBean>> callback) {
    this.enqueue(new GetPersonsRealCall(idList, token, callback));
  }

  @Override
  public void getProperties(String prefix, Token token,
      ServiceMethodCallback<Map<String, String>> callback) {
    this.enqueue(new GetPropertiesCall(prefix, token, callback));
  }

  @Override
  public void getProperty(String key, Token token, ServiceMethodCallback<String> callback) {
    this.enqueue(new GetPropertyCall(key, token, callback));
  }

  @Override
  public void getRedisParameters(Token token,
      ServiceMethodCallback<Map<MQParam, String>> callback) {
    this.enqueue(new GetRedisParametersCall(token, callback));
  }

  @Override
  public void getServiceConfig(Token token, ServiceMethodCallback<Map<String, String>> callback) {
    this.enqueue(new GetServiceConfigCall(token, callback));
  }

  @Override
  public void getSubDeviceGroup(Integer deviceGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetSubDeviceGroupCall(deviceGroupId, callback));
  }

  @Override
  public void getSubPersonGroup(Integer personGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new GetSubPersonGroupCall(personGroupId, callback));
  }

  @Override
  public void getTargetInfo4PwdOnDevice(String pwd, Token token,
      ServiceMethodCallback<TmpwdTargetInfo> callback) {
    this.enqueue(new GetTargetInfo4PwdOnDeviceCall(pwd, token, callback));
  }

  @Override
  public void initTopGroup(TopGroupInfo groupInfo, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new InitTopGroupCall(groupInfo, token, callback));
  }

  @Override
  public void isDisable(Integer personId, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsDisableCall(personId, callback));
  }

  @Override
  public void isLocal(ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsLocalCall(callback));
  }

  @Override
  public void isValidAckChannel(String ackChannel, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidAckChannelCall(ackChannel, callback));
  }

  @Override
  public void isValidCmdSn(Integer cmdSn, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidCmdSnCall(cmdSn, callback));
  }

  @Override
  public void isValidDeviceToken(Token token, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidDeviceTokenCall(token, callback));
  }

  @Override
  public void isValidPassword(String userId, String password, Boolean isMd5,
      ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidPasswordCall(userId, password, isMd5, callback));
  }

  @Override
  public void isValidPersonToken(Token token, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidPersonTokenCall(token, callback));
  }

  @Override
  public void isValidRootToken(Token token, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidRootTokenCall(token, callback));
  }

  @Override
  public void isValidToken(Token token, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidTokenCall(token, callback));
  }

  @Override
  public void isValidUserToken(Token token, ServiceMethodCallback<Boolean> callback) {
    this.enqueue(new IsValidUserTokenCall(token, callback));
  }

  @Override
  public void iso8601Time(ServiceMethodCallback<String> callback) {
    this.enqueue(new Iso8601TimeCall(callback));
  }

  @Override
  public void listOfParentForDeviceGroup(Integer deviceGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new ListOfParentForDeviceGroupCall(deviceGroupId, callback));
  }

  @Override
  public void listOfParentForPersonGroup(Integer personGroupId,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new ListOfParentForPersonGroupCall(personGroupId, callback));
  }

  @Override
  public void loadAllPerson(ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadAllPersonCall(callback));
  }

  @Override
  public void loadDeviceByWhere(String where, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<DeviceBean>> callback) {
    this.enqueue(new LoadDeviceByWhereCall(where, startRow, numRows, callback));
  }

  @Override
  public void loadDeviceGroupByWhere(String where, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadDeviceGroupByWhereCall(where, startRow, numRows, callback));
  }

  @Override
  public void loadDeviceGroupIdByWhere(String where,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadDeviceGroupIdByWhereCall(where, callback));
  }

  @Override
  public void loadDeviceIdByWhere(String where, ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadDeviceIdByWhereCall(where, callback));
  }

  @Override
  public void loadDistinctIntegerColumn(String table, String column, String where,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadDistinctIntegerColumnCall(table, column, where, callback));
  }

  @Override
  public void loadDistinctStringColumn(String table, String column, String where,
      ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new LoadDistinctStringColumnCall(table, column, where, callback));
  }

  @Override
  public void loadErrorLogByWhere(String where, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<ErrorLogBean>> callback) {
    this.enqueue(new LoadErrorLogByWhereCall(where, startRow, numRows, callback));
  }

  @Override
  public void loadFeatureMd5ByUpdate(Long timestamp, ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new LoadFeatureMd5ByUpdateCall(timestamp, callback));
  }

  @Override
  public void loadFeatureMd5ByUpdateTimeStr(String timestamp,
      ServiceMethodCallback<List<String>> callback) {
    this.enqueue(new LoadFeatureMd5ByUpdateTimeStrCall(timestamp, callback));
  }

  @Override
  public void loadLogByWhere(String where, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<LogBean>> callback) {
    this.enqueue(new LoadLogByWhereCall(where, startRow, numRows, callback));
  }

  @Override
  public void loadLogLightByVerifyTime(Long timestamp, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<LogLightBean>> callback) {
    this.enqueue(new LoadLogLightByVerifyTimeCall(timestamp, startRow, numRows, callback));
  }

  @Override
  public void loadLogLightByVerifyTimeTimestr(String timestamp, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<LogLightBean>> callback) {
    this.enqueue(new LoadLogLightByVerifyTimeTimestrCall(timestamp, startRow, numRows, callback));
  }

  @Override
  public void loadLogLightByWhere(String where, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<LogLightBean>> callback) {
    this.enqueue(new LoadLogLightByWhereCall(where, startRow, numRows, callback));
  }

  @Override
  public void loadPermitByUpdate(Long timestamp, ServiceMethodCallback<List<PermitBean>> callback) {
    this.enqueue(new LoadPermitByUpdateCall(timestamp, callback));
  }

  @Override
  public void loadPermitByUpdateTimestr(String timestamp,
      ServiceMethodCallback<List<PermitBean>> callback) {
    this.enqueue(new LoadPermitByUpdateTimestrCall(timestamp, callback));
  }

  @Override
  public void loadPersonByWhere(String where, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<PersonBean>> callback) {
    this.enqueue(new LoadPersonByWhereCall(where, startRow, numRows, callback));
  }

  @Override
  public void loadPersonByWhereReal(String where, Integer startRow, Integer numRows, Token token,
      ServiceMethodCallback<List<PersonBean>> callback) {
    this.enqueue(new LoadPersonByWhereRealCall(where, startRow, numRows, token, callback));
  }

  @Override
  public void loadPersonGroupByWhere(String where, Integer startRow, Integer numRows,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadPersonGroupByWhereCall(where, startRow, numRows, callback));
  }

  @Override
  public void loadPersonGroupIdByWhere(String where,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadPersonGroupIdByWhereCall(where, callback));
  }

  @Override
  public void loadPersonIdByUpdateTime(Long timestamp,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadPersonIdByUpdateTimeCall(timestamp, callback));
  }

  @Override
  public void loadPersonIdByUpdateTimeTimeStr(String timestamp,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadPersonIdByUpdateTimeTimeStrCall(timestamp, callback));
  }

  @Override
  public void loadPersonIdByWhere(String where, ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadPersonIdByWhereCall(where, callback));
  }

  @Override
  public void loadUpdatedPersons(Long timestamp, ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadUpdatedPersonsCall(timestamp, callback));
  }

  @Override
  public void loadUpdatedPersonsTimestr(String timestamp,
      ServiceMethodCallback<List<Integer>> callback) {
    this.enqueue(new LoadUpdatedPersonsTimestrCall(timestamp, callback));
  }

  @Override
  public void lockWakeup(DeviceBean deviceBean, Boolean ignoreSchedule, String sdkVersion,
      ServiceMethodCallback<LockWakeupResponse> callback) {
    this.enqueue(new LockWakeupCall(deviceBean, ignoreSchedule, sdkVersion, callback));
  }

  @Override
  public void offline(Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new OfflineCall(token, callback));
  }

  @Override
  public void online(DeviceBean device, ServiceMethodCallback<Token> callback) {
    this.enqueue(new OnlineCall(device, callback));
  }

  @Override
  public void registerDevice(DeviceBean newDevice, ServiceMethodCallback<DeviceBean> callback) {
    this.enqueue(new RegisterDeviceCall(newDevice, callback));
  }

  @Override
  public void releasePersonToken(Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new ReleasePersonTokenCall(token, callback));
  }

  @Override
  public void releaseRootToken(Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new ReleaseRootTokenCall(token, callback));
  }

  @Override
  public void releaseUserToken(Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new ReleaseUserTokenCall(token, callback));
  }

  @Override
  public void replaceFeature(Integer personId, String featureMd5, Boolean deleteOldFeatureImage,
      Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new ReplaceFeatureCall(personId, featureMd5, deleteOldFeatureImage, token, callback));
  }

  @Override
  public void rootGroupOfDevice(Integer deviceId, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new RootGroupOfDeviceCall(deviceId, callback));
  }

  @Override
  public void rootGroupOfDeviceGroup(Integer groupId, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new RootGroupOfDeviceGroupCall(groupId, callback));
  }

  @Override
  public void rootGroupOfPerson(Integer personId, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new RootGroupOfPersonCall(personId, callback));
  }

  @Override
  public void rootGroupOfPersonGroup(Integer groupId, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new RootGroupOfPersonGroupCall(groupId, callback));
  }

  @Override
  public void runCmd(List<Integer> target, Boolean group, String cmdpath, String jsonArgs,
      String ackChannel, Token token, ServiceMethodCallback<String> callback) {
    this.enqueue(new RunCmdCall(target, group, cmdpath, jsonArgs, ackChannel, token, callback));
  }

  @Override
  public void runTask(String taskQueue, String cmdpath, String jsonArgs, String ackChannel,
      Token token, ServiceMethodCallback<Integer> callback) {
    this.enqueue(new RunTaskCall(taskQueue, cmdpath, jsonArgs, ackChannel, token, callback));
  }

  @Override
  public void runTaskSync(String taskQueue, String cmdpath, String jsonArgs, Integer timeoutSecs,
      Token token, ServiceMethodCallback<String> callback) {
    this.enqueue(new RunTaskSyncCall(taskQueue, cmdpath, jsonArgs, timeoutSecs, token, callback));
  }

  @Override
  public void saveDevice(DeviceBean deviceBean, Token token,
      ServiceMethodCallback<DeviceBean> callback) {
    this.enqueue(new SaveDeviceCall(deviceBean, token, callback));
  }

  @Override
  public void saveDeviceGroup(DeviceGroupBean deviceGroupBean, Token token,
      ServiceMethodCallback<DeviceGroupBean> callback) {
    this.enqueue(new SaveDeviceGroupCall(deviceGroupBean, token, callback));
  }

  @Override
  public void savePermit(PermitBean permitBean, Token token,
      ServiceMethodCallback<PermitBean> callback) {
    this.enqueue(new SavePermitCall(permitBean, token, callback));
  }

  @Override
  public void savePermitWithColumn(Integer deviceGroupId, Integer personGroupId, String column,
      String value, Token token, ServiceMethodCallback<PermitBean> callback) {
    this.enqueue(new SavePermitWithColumnCall(deviceGroupId, personGroupId, column, value, token, callback));
  }

  @Override
  public void savePerson(PersonBean personBean, Token token,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new SavePersonCall(personBean, token, callback));
  }

  @Override
  public void savePersonFull(PersonBean personBean, ByteString idPhoto, ByteString feature,
      String featureVersion, ByteString featureImage, FaceBean faceBean, Token token,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new SavePersonFullCall(personBean, idPhoto, feature, featureVersion, featureImage, faceBean, token, callback));
  }

  @Override
  public void savePersonGroup(PersonGroupBean personGroupBean, Token token,
      ServiceMethodCallback<PersonGroupBean> callback) {
    this.enqueue(new SavePersonGroupCall(personGroupBean, token, callback));
  }

  @Override
  public void savePersonWithPhoto(PersonBean personBean, ByteString idPhoto, Token token,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new SavePersonWithPhotoCall(personBean, idPhoto, token, callback));
  }

  @Override
  public void savePersonWithPhotoAndFeature(PersonBean personBean, ByteString idPhoto,
      FeatureBean featureBean, Token token, ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new SavePersonWithPhotoAndFeatureCall(personBean, idPhoto, featureBean, token, callback));
  }

  @Override
  public void savePersonWithPhotoAndFeatureMultiFaces(PersonBean personBean, ByteString idPhoto,
      ByteString feature, String featureVersion, List<FaceBean> faceBeans, Token token,
      ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new SavePersonWithPhotoAndFeatureMultiFacesCall(personBean, idPhoto, feature, featureVersion, faceBeans, token, callback));
  }

  @Override
  public void savePersonWithPhotoAndFeatureMultiImage(PersonBean personBean, ByteString idPhoto,
      ByteString feature, String featureVersion, List<ByteString> photos, List<FaceBean> faces,
      Token token, ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new SavePersonWithPhotoAndFeatureMultiImageCall(personBean, idPhoto, feature, featureVersion, photos, faces, token, callback));
  }

  @Override
  public void savePersonWithPhotoAndFeatureSaved(PersonBean personBean, String idPhotoMd5,
      String featureMd5, Token token, ServiceMethodCallback<PersonBean> callback) {
    this.enqueue(new SavePersonWithPhotoAndFeatureSavedCall(personBean, idPhotoMd5, featureMd5, token, callback));
  }

  @Override
  public void savePersons(List<PersonBean> persons, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new SavePersonsCall(persons, token, callback));
  }

  @Override
  public void savePersonsWithPhoto(List<ByteString> photos, List<PersonBean> persons, Token token,
      ServiceMethodCallback<Integer> callback) {
    this.enqueue(new SavePersonsWithPhotoCall(photos, persons, token, callback));
  }

  @Override
  public void saveServiceConfig(Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new SaveServiceConfigCall(token, callback));
  }

  @Override
  public void sdkTaskQueueOf(String task, String sdkVersion, Token token,
      ServiceMethodCallback<String> callback) {
    this.enqueue(new SdkTaskQueueOfCall(task, sdkVersion, token, callback));
  }

  @Override
  public void setPersonExpiryDate(Integer personId, Long expiryDate, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new SetPersonExpiryDateCall(personId, expiryDate, token, callback));
  }

  @Override
  public void setPersonExpiryDateList(List<Integer> personIdList, Long expiryDate, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new SetPersonExpiryDateListCall(personIdList, expiryDate, token, callback));
  }

  @Override
  public void setPersonExpiryDateTimeStr(Integer personId, String expiryDate, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new SetPersonExpiryDateTimeStrCall(personId, expiryDate, token, callback));
  }

  @Override
  public void setProperties(Map<String, String> config, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new SetPropertiesCall(config, token, callback));
  }

  @Override
  public void setProperty(String key, String value, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new SetPropertyCall(key, value, token, callback));
  }

  @Override
  public void taskQueueOf(String task, Token token, ServiceMethodCallback<String> callback) {
    this.enqueue(new TaskQueueOfCall(task, token, callback));
  }

  @Override
  public void unbindBorder(Integer personGroupId, Integer deviceGroupId, Token token,
      ServiceMethodCallback<Void> callback) {
    this.enqueue(new UnbindBorderCall(personGroupId, deviceGroupId, token, callback));
  }

  @Override
  public void unregisterDevice(Token token, ServiceMethodCallback<Void> callback) {
    this.enqueue(new UnregisterDeviceCall(token, callback));
  }

  @Override
  public void updateDevice(DeviceBean deviceBean, Token token,
      ServiceMethodCallback<DeviceBean> callback) {
    this.enqueue(new UpdateDeviceCall(deviceBean, token, callback));
  }

  @Override
  public void version(ServiceMethodCallback<String> callback) {
    this.enqueue(new VersionCall(callback));
  }

  @Override
  public void versionInfo(ServiceMethodCallback<Map<String, String>> callback) {
    this.enqueue(new VersionInfoCall(callback));
  }

  private static final class AddErrorLogCall extends MethodCall<Void> {
    private final ErrorLogBean errorLogBean;

    private final Token token;

    AddErrorLogCall(ErrorLogBean errorLogBean, Token token, ServiceMethodCallback<Void> callback) {
      super("addErrorLog", TMessageType.CALL, callback);
      this.errorLogBean = errorLogBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.errorLogBean != null) {
        protocol.writeFieldBegin("errorLogBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.ErrorLogBean.ADAPTER.write(protocol, this.errorLogBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class AddFeatureCall extends MethodCall<FeatureBean> {
    private final ByteString feature;

    private final String featureVersion;

    private final Integer personId;

    private final List<FaceBean> faecBeans;

    private final String removed;

    private final Token token;

    AddFeatureCall(ByteString feature, String featureVersion, Integer personId,
        List<FaceBean> faecBeans, String removed, Token token,
        ServiceMethodCallback<FeatureBean> callback) {
      super("addFeature", TMessageType.CALL, callback);
      this.feature = feature;
      this.featureVersion = featureVersion;
      this.personId = personId;
      this.faecBeans = faecBeans;
      this.removed = removed;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.feature != null) {
        protocol.writeFieldBegin("feature", 1, TType.STRING);
        protocol.writeBinary(this.feature);
        protocol.writeFieldEnd();
      }
      if (this.featureVersion != null) {
        protocol.writeFieldBegin("featureVersion", 2, TType.STRING);
        protocol.writeString(this.featureVersion);
        protocol.writeFieldEnd();
      }
      if (this.personId != null) {
        protocol.writeFieldBegin("personId", 3, TType.I32);
        protocol.writeI32(this.personId);
        protocol.writeFieldEnd();
      }
      if (this.faecBeans != null) {
        protocol.writeFieldBegin("faecBeans", 4, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.faecBeans.size());
        for (FaceBean item0 : this.faecBeans) {
          net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.removed != null) {
        protocol.writeFieldBegin("removed", 5, TType.STRING);
        protocol.writeString(this.removed);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 6, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected FeatureBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      FeatureBean result = null;
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.FeatureBean value = net.gdface.facelog.client.thrift.FeatureBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class AddFeatureMultiCall extends MethodCall<FeatureBean> {
    private final ByteString feature;

    private final String featureVersion;

    private final Integer personId;

    private final List<ByteString> photos;

    private final List<FaceBean> faces;

    private final String removed;

    private final Token token;

    AddFeatureMultiCall(ByteString feature, String featureVersion, Integer personId,
        List<ByteString> photos, List<FaceBean> faces, String removed, Token token,
        ServiceMethodCallback<FeatureBean> callback) {
      super("addFeatureMulti", TMessageType.CALL, callback);
      this.feature = feature;
      this.featureVersion = featureVersion;
      this.personId = personId;
      this.photos = photos;
      this.faces = faces;
      this.removed = removed;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.feature != null) {
        protocol.writeFieldBegin("feature", 1, TType.STRING);
        protocol.writeBinary(this.feature);
        protocol.writeFieldEnd();
      }
      if (this.featureVersion != null) {
        protocol.writeFieldBegin("featureVersion", 2, TType.STRING);
        protocol.writeString(this.featureVersion);
        protocol.writeFieldEnd();
      }
      if (this.personId != null) {
        protocol.writeFieldBegin("personId", 3, TType.I32);
        protocol.writeI32(this.personId);
        protocol.writeFieldEnd();
      }
      if (this.photos != null) {
        protocol.writeFieldBegin("photos", 4, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.photos.size());
        for (ByteString item0 : this.photos) {
          protocol.writeBinary(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.faces != null) {
        protocol.writeFieldBegin("faces", 5, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.faces.size());
        for (FaceBean item0 : this.faces) {
          net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.removed != null) {
        protocol.writeFieldBegin("removed", 6, TType.STRING);
        protocol.writeString(this.removed);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 7, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected FeatureBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      FeatureBean result = null;
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.FeatureBean value = net.gdface.facelog.client.thrift.FeatureBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class AddFeatureWithImageCall extends MethodCall<FeatureBean> {
    private final ByteString feature;

    private final String featureVersion;

    private final Integer personId;

    private final Boolean asIdPhotoIfAbsent;

    private final ByteString featurePhoto;

    private final FaceBean faceBean;

    private final String removed;

    private final Token token;

    AddFeatureWithImageCall(ByteString feature, String featureVersion, Integer personId,
        Boolean asIdPhotoIfAbsent, ByteString featurePhoto, FaceBean faceBean, String removed,
        Token token, ServiceMethodCallback<FeatureBean> callback) {
      super("addFeatureWithImage", TMessageType.CALL, callback);
      this.feature = feature;
      this.featureVersion = featureVersion;
      this.personId = personId;
      if (asIdPhotoIfAbsent == null) throw new NullPointerException("asIdPhotoIfAbsent");
      this.asIdPhotoIfAbsent = asIdPhotoIfAbsent;
      this.featurePhoto = featurePhoto;
      this.faceBean = faceBean;
      this.removed = removed;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.feature != null) {
        protocol.writeFieldBegin("feature", 1, TType.STRING);
        protocol.writeBinary(this.feature);
        protocol.writeFieldEnd();
      }
      if (this.featureVersion != null) {
        protocol.writeFieldBegin("featureVersion", 2, TType.STRING);
        protocol.writeString(this.featureVersion);
        protocol.writeFieldEnd();
      }
      if (this.personId != null) {
        protocol.writeFieldBegin("personId", 3, TType.I32);
        protocol.writeI32(this.personId);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("asIdPhotoIfAbsent", 4, TType.BOOL);
      protocol.writeBool(this.asIdPhotoIfAbsent);
      protocol.writeFieldEnd();
      if (this.featurePhoto != null) {
        protocol.writeFieldBegin("featurePhoto", 5, TType.STRING);
        protocol.writeBinary(this.featurePhoto);
        protocol.writeFieldEnd();
      }
      if (this.faceBean != null) {
        protocol.writeFieldBegin("faceBean", 6, TType.STRUCT);
        net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, this.faceBean);
        protocol.writeFieldEnd();
      }
      if (this.removed != null) {
        protocol.writeFieldBegin("removed", 7, TType.STRING);
        protocol.writeString(this.removed);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 8, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected FeatureBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      FeatureBean result = null;
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.FeatureBean value = net.gdface.facelog.client.thrift.FeatureBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class AddImageCall extends MethodCall<ImageBean> {
    private final ByteString imageData;

    private final Integer deviceId;

    private final FaceBean faceBean;

    private final Integer personId;

    private final Token token;

    AddImageCall(ByteString imageData, Integer deviceId, FaceBean faceBean, Integer personId,
        Token token, ServiceMethodCallback<ImageBean> callback) {
      super("addImage", TMessageType.CALL, callback);
      this.imageData = imageData;
      this.deviceId = deviceId;
      this.faceBean = faceBean;
      this.personId = personId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.imageData != null) {
        protocol.writeFieldBegin("imageData", 1, TType.STRING);
        protocol.writeBinary(this.imageData);
        protocol.writeFieldEnd();
      }
      if (this.deviceId != null) {
        protocol.writeFieldBegin("deviceId", 2, TType.I32);
        protocol.writeI32(this.deviceId);
        protocol.writeFieldEnd();
      }
      if (this.faceBean != null) {
        protocol.writeFieldBegin("faceBean", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, this.faceBean);
        protocol.writeFieldEnd();
      }
      if (this.personId != null) {
        protocol.writeFieldBegin("personId", 4, TType.I32);
        protocol.writeI32(this.personId);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 5, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected ImageBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ImageBean result = null;
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ImageBean value = net.gdface.facelog.client.thrift.ImageBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class AddLogCall extends MethodCall<Void> {
    private final LogBean logBean;

    private final Token token;

    AddLogCall(LogBean logBean, Token token, ServiceMethodCallback<Void> callback) {
      super("addLog", TMessageType.CALL, callback);
      this.logBean = logBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.logBean != null) {
        protocol.writeFieldBegin("logBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.LogBean.ADAPTER.write(protocol, this.logBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class AddLogFullCall extends MethodCall<Void> {
    private final LogBean logBean;

    private final FaceBean faceBean;

    private final ByteString featureImage;

    private final Token token;

    AddLogFullCall(LogBean logBean, FaceBean faceBean, ByteString featureImage, Token token,
        ServiceMethodCallback<Void> callback) {
      super("addLogFull", TMessageType.CALL, callback);
      this.logBean = logBean;
      this.faceBean = faceBean;
      this.featureImage = featureImage;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.logBean != null) {
        protocol.writeFieldBegin("logBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.LogBean.ADAPTER.write(protocol, this.logBean);
        protocol.writeFieldEnd();
      }
      if (this.faceBean != null) {
        protocol.writeFieldBegin("faceBean", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, this.faceBean);
        protocol.writeFieldEnd();
      }
      if (this.featureImage != null) {
        protocol.writeFieldBegin("featureImage", 3, TType.STRING);
        protocol.writeBinary(this.featureImage);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class AddLogWithFaceImageCall extends MethodCall<Void> {
    private final LogBean logBean;

    private final ByteString faceImage;

    private final Token token;

    AddLogWithFaceImageCall(LogBean logBean, ByteString faceImage, Token token,
        ServiceMethodCallback<Void> callback) {
      super("addLogWithFaceImage", TMessageType.CALL, callback);
      this.logBean = logBean;
      this.faceImage = faceImage;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.logBean != null) {
        protocol.writeFieldBegin("logBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.LogBean.ADAPTER.write(protocol, this.logBean);
        protocol.writeFieldEnd();
      }
      if (this.faceImage != null) {
        protocol.writeFieldBegin("faceImage", 2, TType.STRING);
        protocol.writeBinary(this.faceImage);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class AddLogsCall extends MethodCall<Void> {
    private final List<LogBean> beans;

    private final Token token;

    AddLogsCall(List<LogBean> beans, Token token, ServiceMethodCallback<Void> callback) {
      super("addLogs", TMessageType.CALL, callback);
      this.beans = beans;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.beans != null) {
        protocol.writeFieldBegin("beans", 1, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.beans.size());
        for (LogBean item0 : this.beans) {
          net.gdface.facelog.client.thrift.LogBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class AddLogsFullCall extends MethodCall<Void> {
    private final List<LogBean> logBeans;

    private final List<FaceBean> faceBeans;

    private final List<ByteString> featureImages;

    private final Token token;

    AddLogsFullCall(List<LogBean> logBeans, List<FaceBean> faceBeans,
        List<ByteString> featureImages, Token token, ServiceMethodCallback<Void> callback) {
      super("addLogsFull", TMessageType.CALL, callback);
      this.logBeans = logBeans;
      this.faceBeans = faceBeans;
      this.featureImages = featureImages;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.logBeans != null) {
        protocol.writeFieldBegin("logBeans", 1, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.logBeans.size());
        for (LogBean item0 : this.logBeans) {
          net.gdface.facelog.client.thrift.LogBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.faceBeans != null) {
        protocol.writeFieldBegin("faceBeans", 2, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.faceBeans.size());
        for (FaceBean item0 : this.faceBeans) {
          net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.featureImages != null) {
        protocol.writeFieldBegin("featureImages", 3, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.featureImages.size());
        for (ByteString item0 : this.featureImages) {
          protocol.writeBinary(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class AddLogsWithFaceImageCall extends MethodCall<Void> {
    private final List<LogBean> logBeans;

    private final List<ByteString> faceImages;

    private final Token token;

    AddLogsWithFaceImageCall(List<LogBean> logBeans, List<ByteString> faceImages, Token token,
        ServiceMethodCallback<Void> callback) {
      super("addLogsWithFaceImage", TMessageType.CALL, callback);
      this.logBeans = logBeans;
      this.faceImages = faceImages;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.logBeans != null) {
        protocol.writeFieldBegin("logBeans", 1, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.logBeans.size());
        for (LogBean item0 : this.logBeans) {
          net.gdface.facelog.client.thrift.LogBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.faceImages != null) {
        protocol.writeFieldBegin("faceImages", 2, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.faceImages.size());
        for (ByteString item0 : this.faceImages) {
          protocol.writeBinary(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DuplicateRecordException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DuplicateRecordException value = net.gdface.facelog.client.thrift.DuplicateRecordException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class ApplyAckChannelCall extends MethodCall<String> {
    private final Token token;

    ApplyAckChannelCall(Token token, ServiceMethodCallback<String> callback) {
      super("applyAckChannel", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ApplyAckChannelWithDurationCall extends MethodCall<String> {
    private final Integer duration;

    private final Token token;

    ApplyAckChannelWithDurationCall(Integer duration, Token token,
        ServiceMethodCallback<String> callback) {
      super("applyAckChannelWithDuration", TMessageType.CALL, callback);
      if (duration == null) throw new NullPointerException("duration");
      this.duration = duration;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("duration", 1, TType.I32);
      protocol.writeI32(this.duration);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ApplyCmdSnCall extends MethodCall<Integer> {
    private final Token token;

    ApplyCmdSnCall(Token token, ServiceMethodCallback<Integer> callback) {
      super("applyCmdSn", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ApplyPersonTokenCall extends MethodCall<Token> {
    private final Integer personId;

    private final String password;

    private final Boolean isMd5;

    ApplyPersonTokenCall(Integer personId, String password, Boolean isMd5,
        ServiceMethodCallback<Token> callback) {
      super("applyPersonToken", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.password = password;
      if (isMd5 == null) throw new NullPointerException("isMd5");
      this.isMd5 = isMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.password != null) {
        protocol.writeFieldBegin("password", 2, TType.STRING);
        protocol.writeString(this.password);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("isMd5", 3, TType.BOOL);
      protocol.writeBool(this.isMd5);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Token receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Token result = null;
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.Token value = net.gdface.facelog.client.thrift.Token.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ApplyRootTokenCall extends MethodCall<Token> {
    private final String password;

    private final Boolean isMd5;

    ApplyRootTokenCall(String password, Boolean isMd5, ServiceMethodCallback<Token> callback) {
      super("applyRootToken", TMessageType.CALL, callback);
      this.password = password;
      if (isMd5 == null) throw new NullPointerException("isMd5");
      this.isMd5 = isMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.password != null) {
        protocol.writeFieldBegin("password", 1, TType.STRING);
        protocol.writeString(this.password);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("isMd5", 2, TType.BOOL);
      protocol.writeBool(this.isMd5);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Token receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Token result = null;
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.Token value = net.gdface.facelog.client.thrift.Token.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ApplyUserTokenCall extends MethodCall<Token> {
    private final Integer userid;

    private final String password;

    private final Boolean isMd5;

    ApplyUserTokenCall(Integer userid, String password, Boolean isMd5,
        ServiceMethodCallback<Token> callback) {
      super("applyUserToken", TMessageType.CALL, callback);
      if (userid == null) throw new NullPointerException("userid");
      this.userid = userid;
      this.password = password;
      if (isMd5 == null) throw new NullPointerException("isMd5");
      this.isMd5 = isMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("userid", 1, TType.I32);
      protocol.writeI32(this.userid);
      protocol.writeFieldEnd();
      if (this.password != null) {
        protocol.writeFieldBegin("password", 2, TType.STRING);
        protocol.writeString(this.password);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("isMd5", 3, TType.BOOL);
      protocol.writeBool(this.isMd5);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Token receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Token result = null;
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.Token value = net.gdface.facelog.client.thrift.Token.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class BindBorderCall extends MethodCall<Void> {
    private final Integer personGroupId;

    private final Integer deviceGroupId;

    private final Token token;

    BindBorderCall(Integer personGroupId, Integer deviceGroupId, Token token,
        ServiceMethodCallback<Void> callback) {
      super("bindBorder", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("deviceGroupId", 2, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class ChildListForDeviceGroupCall extends MethodCall<List<Integer>> {
    private final Integer deviceGroupId;

    ChildListForDeviceGroupCall(Integer deviceGroupId,
        ServiceMethodCallback<List<Integer>> callback) {
      super("childListForDeviceGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ChildListForPersonGroupCall extends MethodCall<List<Integer>> {
    private final Integer personGroupId;

    ChildListForPersonGroupCall(Integer personGroupId,
        ServiceMethodCallback<List<Integer>> callback) {
      super("childListForPersonGroup", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountDeviceByWhereCall extends MethodCall<Integer> {
    private final String where;

    CountDeviceByWhereCall(String where, ServiceMethodCallback<Integer> callback) {
      super("countDeviceByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountDeviceGroupByWhereCall extends MethodCall<Integer> {
    private final String where;

    CountDeviceGroupByWhereCall(String where, ServiceMethodCallback<Integer> callback) {
      super("countDeviceGroupByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountErrorLogByWhereCall extends MethodCall<Integer> {
    private final String where;

    CountErrorLogByWhereCall(String where, ServiceMethodCallback<Integer> callback) {
      super("countErrorLogByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountLogByWhereCall extends MethodCall<Integer> {
    private final String where;

    CountLogByWhereCall(String where, ServiceMethodCallback<Integer> callback) {
      super("countLogByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountLogLightByVerifyTimeCall extends MethodCall<Integer> {
    private final Long timestamp;

    CountLogLightByVerifyTimeCall(Long timestamp, ServiceMethodCallback<Integer> callback) {
      super("countLogLightByVerifyTime", TMessageType.CALL, callback);
      if (timestamp == null) throw new NullPointerException("timestamp");
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("timestamp", 1, TType.I64);
      protocol.writeI64(this.timestamp);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountLogLightByVerifyTimeTimestrCall extends MethodCall<Integer> {
    private final String timestamp;

    CountLogLightByVerifyTimeTimestrCall(String timestamp,
        ServiceMethodCallback<Integer> callback) {
      super("countLogLightByVerifyTimeTimestr", TMessageType.CALL, callback);
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 1, TType.STRING);
        protocol.writeString(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountLogLightByWhereCall extends MethodCall<Integer> {
    private final String where;

    CountLogLightByWhereCall(String where, ServiceMethodCallback<Integer> callback) {
      super("countLogLightByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountPersonByWhereCall extends MethodCall<Integer> {
    private final String where;

    CountPersonByWhereCall(String where, ServiceMethodCallback<Integer> callback) {
      super("countPersonByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountPersonGroupByWhereCall extends MethodCall<Integer> {
    private final String where;

    CountPersonGroupByWhereCall(String where, ServiceMethodCallback<Integer> callback) {
      super("countPersonGroupByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountPersonLogCall extends MethodCall<Map<String, Integer>> {
    private final Integer personId;

    private final Long startDate;

    private final Long endDate;

    CountPersonLogCall(Integer personId, Long startDate, Long endDate,
        ServiceMethodCallback<Map<String, Integer>> callback) {
      super("countPersonLog", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.startDate = startDate;
      this.endDate = endDate;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.startDate != null) {
        protocol.writeFieldBegin("startDate", 2, TType.I64);
        protocol.writeI64(this.startDate);
        protocol.writeFieldEnd();
      }
      if (this.endDate != null) {
        protocol.writeFieldBegin("endDate", 3, TType.I64);
        protocol.writeI64(this.endDate);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<String, Integer> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<String, Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<String, Integer> value = new HashMap<String, Integer>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                String key0 = protocol.readString();
                int value0 = protocol.readI32();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CountPersonLogTimeStrCall extends MethodCall<Map<String, Integer>> {
    private final Integer personId;

    private final String startDate;

    private final String endDate;

    CountPersonLogTimeStrCall(Integer personId, String startDate, String endDate,
        ServiceMethodCallback<Map<String, Integer>> callback) {
      super("countPersonLogTimeStr", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.startDate = startDate;
      this.endDate = endDate;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.startDate != null) {
        protocol.writeFieldBegin("startDate", 2, TType.STRING);
        protocol.writeString(this.startDate);
        protocol.writeFieldEnd();
      }
      if (this.endDate != null) {
        protocol.writeFieldBegin("endDate", 3, TType.STRING);
        protocol.writeString(this.endDate);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<String, Integer> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<String, Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<String, Integer> value = new HashMap<String, Integer>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                String key0 = protocol.readString();
                int value0 = protocol.readI32();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CreateTempPwdCall extends MethodCall<String> {
    private final Integer targetId;

    private final TmpPwdTargetType targetType;

    private final String expiryDate;

    private final Token token;

    CreateTempPwdCall(Integer targetId, TmpPwdTargetType targetType, String expiryDate, Token token,
        ServiceMethodCallback<String> callback) {
      super("createTempPwd", TMessageType.CALL, callback);
      if (targetId == null) throw new NullPointerException("targetId");
      this.targetId = targetId;
      this.targetType = targetType;
      this.expiryDate = expiryDate;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("targetId", 1, TType.I32);
      protocol.writeI32(this.targetId);
      protocol.writeFieldEnd();
      if (this.targetType != null) {
        protocol.writeFieldBegin("targetType", 2, TType.I32);
        protocol.writeI32(this.targetType.value);
        protocol.writeFieldEnd();
      }
      if (this.expiryDate != null) {
        protocol.writeFieldBegin("expiryDate", 3, TType.STRING);
        protocol.writeString(this.expiryDate);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class CreateTempPwdWithDurationCall extends MethodCall<String> {
    private final Integer targetId;

    private final TmpPwdTargetType targetType;

    private final Integer duration;

    private final Token token;

    CreateTempPwdWithDurationCall(Integer targetId, TmpPwdTargetType targetType, Integer duration,
        Token token, ServiceMethodCallback<String> callback) {
      super("createTempPwdWithDuration", TMessageType.CALL, callback);
      if (targetId == null) throw new NullPointerException("targetId");
      this.targetId = targetId;
      this.targetType = targetType;
      if (duration == null) throw new NullPointerException("duration");
      this.duration = duration;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("targetId", 1, TType.I32);
      protocol.writeI32(this.targetId);
      protocol.writeFieldEnd();
      if (this.targetType != null) {
        protocol.writeFieldBegin("targetType", 2, TType.I32);
        protocol.writeI32(this.targetType.value);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("duration", 3, TType.I32);
      protocol.writeI32(this.duration);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteAllFeaturesByPersonIdCall extends MethodCall<Integer> {
    private final Integer personId;

    private final Boolean deleteImage;

    private final Token token;

    DeleteAllFeaturesByPersonIdCall(Integer personId, Boolean deleteImage, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deleteAllFeaturesByPersonId", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      if (deleteImage == null) throw new NullPointerException("deleteImage");
      this.deleteImage = deleteImage;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("deleteImage", 2, TType.BOOL);
      protocol.writeBool(this.deleteImage);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteDeviceCall extends MethodCall<Boolean> {
    private final Integer id;

    private final Token token;

    DeleteDeviceCall(Integer id, Token token, ServiceMethodCallback<Boolean> callback) {
      super("deleteDevice", TMessageType.CALL, callback);
      if (id == null) throw new NullPointerException("id");
      this.id = id;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("id", 1, TType.I32);
      protocol.writeI32(this.id);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteDeviceByMacCall extends MethodCall<Boolean> {
    private final String mac;

    private final Token token;

    DeleteDeviceByMacCall(String mac, Token token, ServiceMethodCallback<Boolean> callback) {
      super("deleteDeviceByMac", TMessageType.CALL, callback);
      this.mac = mac;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.mac != null) {
        protocol.writeFieldBegin("mac", 1, TType.STRING);
        protocol.writeString(this.mac);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteDeviceGroupCall extends MethodCall<Integer> {
    private final Integer deviceGroupId;

    private final Token token;

    DeleteDeviceGroupCall(Integer deviceGroupId, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deleteDeviceGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteErrorLogByWhereCall extends MethodCall<Integer> {
    private final String where;

    private final Token token;

    DeleteErrorLogByWhereCall(String where, Token token, ServiceMethodCallback<Integer> callback) {
      super("deleteErrorLogByWhere", TMessageType.CALL, callback);
      this.where = where;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteFeatureCall extends MethodCall<List<String>> {
    private final String featureMd5;

    private final Boolean deleteImage;

    private final Token token;

    DeleteFeatureCall(String featureMd5, Boolean deleteImage, Token token,
        ServiceMethodCallback<List<String>> callback) {
      super("deleteFeature", TMessageType.CALL, callback);
      this.featureMd5 = featureMd5;
      if (deleteImage == null) throw new NullPointerException("deleteImage");
      this.deleteImage = deleteImage;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.featureMd5 != null) {
        protocol.writeFieldBegin("featureMd5", 1, TType.STRING);
        protocol.writeString(this.featureMd5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("deleteImage", 2, TType.BOOL);
      protocol.writeBool(this.deleteImage);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteGroupPermitOnDeviceGroupCall extends MethodCall<Integer> {
    private final Integer deviceGroupId;

    private final Token token;

    DeleteGroupPermitOnDeviceGroupCall(Integer deviceGroupId, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deleteGroupPermitOnDeviceGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteImageCall extends MethodCall<Integer> {
    private final String imageMd5;

    private final Token token;

    DeleteImageCall(String imageMd5, Token token, ServiceMethodCallback<Integer> callback) {
      super("deleteImage", TMessageType.CALL, callback);
      this.imageMd5 = imageMd5;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.imageMd5 != null) {
        protocol.writeFieldBegin("imageMd5", 1, TType.STRING);
        protocol.writeString(this.imageMd5);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeleteLogByWhereCall extends MethodCall<Integer> {
    private final String where;

    private final Token token;

    DeleteLogByWhereCall(String where, Token token, ServiceMethodCallback<Integer> callback) {
      super("deleteLogByWhere", TMessageType.CALL, callback);
      this.where = where;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeletePermitByIdCall extends MethodCall<Integer> {
    private final Integer deviceGroupId;

    private final Integer personGroupId;

    private final Token token;

    DeletePermitByIdCall(Integer deviceGroupId, Integer personGroupId, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deletePermitById", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("personGroupId", 2, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeletePersonCall extends MethodCall<Integer> {
    private final Integer personId;

    private final Token token;

    DeletePersonCall(Integer personId, Token token, ServiceMethodCallback<Integer> callback) {
      super("deletePerson", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeletePersonByPapersNumCall extends MethodCall<Integer> {
    private final String papersNum;

    private final Token token;

    DeletePersonByPapersNumCall(String papersNum, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deletePersonByPapersNum", TMessageType.CALL, callback);
      this.papersNum = papersNum;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.papersNum != null) {
        protocol.writeFieldBegin("papersNum", 1, TType.STRING);
        protocol.writeString(this.papersNum);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeletePersonGroupCall extends MethodCall<Integer> {
    private final Integer personGroupId;

    private final Token token;

    DeletePersonGroupCall(Integer personGroupId, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deletePersonGroup", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeletePersonGroupPermitCall extends MethodCall<Integer> {
    private final Integer personGroupId;

    private final Token token;

    DeletePersonGroupPermitCall(Integer personGroupId, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deletePersonGroupPermit", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeletePersonsCall extends MethodCall<Integer> {
    private final List<Integer> personIdList;

    private final Token token;

    DeletePersonsCall(List<Integer> personIdList, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deletePersons", TMessageType.CALL, callback);
      this.personIdList = personIdList;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personIdList != null) {
        protocol.writeFieldBegin("personIdList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.personIdList.size());
        for (Integer item0 : this.personIdList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DeletePersonsByPapersNumCall extends MethodCall<Integer> {
    private final List<String> papersNumlist;

    private final Token token;

    DeletePersonsByPapersNumCall(List<String> papersNumlist, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("deletePersonsByPapersNum", TMessageType.CALL, callback);
      this.papersNumlist = papersNumlist;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.papersNumlist != null) {
        protocol.writeFieldBegin("papersNumlist", 1, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.papersNumlist.size());
        for (String item0 : this.papersNumlist) {
          protocol.writeString(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class DisablePersonCall extends MethodCall<Void> {
    private final Integer personId;

    private final Integer moveToGroupId;

    private final Boolean deletePhoto;

    private final Boolean deleteFeature;

    private final Boolean deleteLog;

    private final Token token;

    DisablePersonCall(Integer personId, Integer moveToGroupId, Boolean deletePhoto,
        Boolean deleteFeature, Boolean deleteLog, Token token,
        ServiceMethodCallback<Void> callback) {
      super("disablePerson", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.moveToGroupId = moveToGroupId;
      if (deletePhoto == null) throw new NullPointerException("deletePhoto");
      this.deletePhoto = deletePhoto;
      if (deleteFeature == null) throw new NullPointerException("deleteFeature");
      this.deleteFeature = deleteFeature;
      if (deleteLog == null) throw new NullPointerException("deleteLog");
      this.deleteLog = deleteLog;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.moveToGroupId != null) {
        protocol.writeFieldBegin("moveToGroupId", 2, TType.I32);
        protocol.writeI32(this.moveToGroupId);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("deletePhoto", 3, TType.BOOL);
      protocol.writeBool(this.deletePhoto);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("deleteFeature", 4, TType.BOOL);
      protocol.writeBool(this.deleteFeature);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("deleteLog", 5, TType.BOOL);
      protocol.writeBool(this.deleteLog);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 6, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class DisablePersonListCall extends MethodCall<Void> {
    private final List<Integer> personIdList;

    private final Token token;

    DisablePersonListCall(List<Integer> personIdList, Token token,
        ServiceMethodCallback<Void> callback) {
      super("disablePersonList", TMessageType.CALL, callback);
      this.personIdList = personIdList;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personIdList != null) {
        protocol.writeFieldBegin("personIdList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.personIdList.size());
        for (Integer item0 : this.personIdList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class ExistsDeviceCall extends MethodCall<Boolean> {
    private final Integer id;

    ExistsDeviceCall(Integer id, ServiceMethodCallback<Boolean> callback) {
      super("existsDevice", TMessageType.CALL, callback);
      if (id == null) throw new NullPointerException("id");
      this.id = id;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("id", 1, TType.I32);
      protocol.writeI32(this.id);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ExistsFeatureCall extends MethodCall<Boolean> {
    private final String md5;

    ExistsFeatureCall(String md5, ServiceMethodCallback<Boolean> callback) {
      super("existsFeature", TMessageType.CALL, callback);
      this.md5 = md5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.md5 != null) {
        protocol.writeFieldBegin("md5", 1, TType.STRING);
        protocol.writeString(this.md5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ExistsImageCall extends MethodCall<Boolean> {
    private final String md5;

    ExistsImageCall(String md5, ServiceMethodCallback<Boolean> callback) {
      super("existsImage", TMessageType.CALL, callback);
      this.md5 = md5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.md5 != null) {
        protocol.writeFieldBegin("md5", 1, TType.STRING);
        protocol.writeString(this.md5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ExistsPersonCall extends MethodCall<Boolean> {
    private final Integer persionId;

    ExistsPersonCall(Integer persionId, ServiceMethodCallback<Boolean> callback) {
      super("existsPerson", TMessageType.CALL, callback);
      if (persionId == null) throw new NullPointerException("persionId");
      this.persionId = persionId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("persionId", 1, TType.I32);
      protocol.writeI32(this.persionId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class FaceRecognizePersonPermittedCall extends MethodCall<Integer> {
    private final ByteString imageData;

    private final Double threshold;

    private final Integer deviceId;

    FaceRecognizePersonPermittedCall(ByteString imageData, Double threshold, Integer deviceId,
        ServiceMethodCallback<Integer> callback) {
      super("faceRecognizePersonPermitted", TMessageType.CALL, callback);
      this.imageData = imageData;
      this.threshold = threshold;
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.imageData != null) {
        protocol.writeFieldBegin("imageData", 1, TType.STRING);
        protocol.writeBinary(this.imageData);
        protocol.writeFieldEnd();
      }
      if (this.threshold != null) {
        protocol.writeFieldBegin("threshold", 2, TType.DOUBLE);
        protocol.writeDouble(this.threshold);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("deviceId", 3, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceCall extends MethodCall<DeviceBean> {
    private final Integer deviceId;

    GetDeviceCall(Integer deviceId, ServiceMethodCallback<DeviceBean> callback) {
      super("getDevice", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected DeviceBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DeviceBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DeviceBean value = net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceByMacCall extends MethodCall<DeviceBean> {
    private final String mac;

    GetDeviceByMacCall(String mac, ServiceMethodCallback<DeviceBean> callback) {
      super("getDeviceByMac", TMessageType.CALL, callback);
      this.mac = mac;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.mac != null) {
        protocol.writeFieldBegin("mac", 1, TType.STRING);
        protocol.writeString(this.mac);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected DeviceBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DeviceBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DeviceBean value = net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceGroupCall extends MethodCall<DeviceGroupBean> {
    private final Integer deviceGroupId;

    GetDeviceGroupCall(Integer deviceGroupId, ServiceMethodCallback<DeviceGroupBean> callback) {
      super("getDeviceGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected DeviceGroupBean receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      DeviceGroupBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DeviceGroupBean value = net.gdface.facelog.client.thrift.DeviceGroupBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceGroupsCall extends MethodCall<List<DeviceGroupBean>> {
    private final List<Integer> groupIdList;

    GetDeviceGroupsCall(List<Integer> groupIdList,
        ServiceMethodCallback<List<DeviceGroupBean>> callback) {
      super("getDeviceGroups", TMessageType.CALL, callback);
      this.groupIdList = groupIdList;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.groupIdList != null) {
        protocol.writeFieldBegin("groupIdList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.groupIdList.size());
        for (Integer item0 : this.groupIdList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<DeviceGroupBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<DeviceGroupBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<DeviceGroupBean> value = new ArrayList<DeviceGroupBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.DeviceGroupBean item0 = net.gdface.facelog.client.thrift.DeviceGroupBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceGroupsBelongsCall extends MethodCall<List<Integer>> {
    private final Integer deviceId;

    GetDeviceGroupsBelongsCall(Integer deviceId, ServiceMethodCallback<List<Integer>> callback) {
      super("getDeviceGroupsBelongs", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceGroupsPermitCall extends MethodCall<List<Integer>> {
    private final Integer personGroupId;

    GetDeviceGroupsPermitCall(Integer personGroupId,
        ServiceMethodCallback<List<Integer>> callback) {
      super("getDeviceGroupsPermit", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceGroupsPermittedByCall extends MethodCall<List<Integer>> {
    private final Integer personGroupId;

    GetDeviceGroupsPermittedByCall(Integer personGroupId,
        ServiceMethodCallback<List<Integer>> callback) {
      super("getDeviceGroupsPermittedBy", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDeviceIdOfFeatureCall extends MethodCall<Integer> {
    private final String featureMd5;

    GetDeviceIdOfFeatureCall(String featureMd5, ServiceMethodCallback<Integer> callback) {
      super("getDeviceIdOfFeature", TMessageType.CALL, callback);
      this.featureMd5 = featureMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.featureMd5 != null) {
        protocol.writeFieldBegin("featureMd5", 1, TType.STRING);
        protocol.writeString(this.featureMd5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDevicesCall extends MethodCall<List<DeviceBean>> {
    private final List<Integer> idList;

    GetDevicesCall(List<Integer> idList, ServiceMethodCallback<List<DeviceBean>> callback) {
      super("getDevices", TMessageType.CALL, callback);
      this.idList = idList;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.idList != null) {
        protocol.writeFieldBegin("idList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.idList.size());
        for (Integer item0 : this.idList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<DeviceBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<DeviceBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<DeviceBean> value = new ArrayList<DeviceBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.DeviceBean item0 = net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetDevicesOfGroupCall extends MethodCall<List<Integer>> {
    private final Integer deviceGroupId;

    GetDevicesOfGroupCall(Integer deviceGroupId, ServiceMethodCallback<List<Integer>> callback) {
      super("getDevicesOfGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFaceCall extends MethodCall<FaceBean> {
    private final Integer faceId;

    GetFaceCall(Integer faceId, ServiceMethodCallback<FaceBean> callback) {
      super("getFace", TMessageType.CALL, callback);
      if (faceId == null) throw new NullPointerException("faceId");
      this.faceId = faceId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("faceId", 1, TType.I32);
      protocol.writeI32(this.faceId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected FaceBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      FaceBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.FaceBean value = net.gdface.facelog.client.thrift.FaceBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFaceApiParametersCall extends MethodCall<Map<String, String>> {
    private final Token token;

    GetFaceApiParametersCall(Token token, ServiceMethodCallback<Map<String, String>> callback) {
      super("getFaceApiParameters", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<String, String> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<String, String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<String, String> value = new HashMap<String, String>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                String key0 = protocol.readString();
                String value0 = protocol.readString();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFacesOfFeatureCall extends MethodCall<List<FaceBean>> {
    private final String featureMd5;

    GetFacesOfFeatureCall(String featureMd5, ServiceMethodCallback<List<FaceBean>> callback) {
      super("getFacesOfFeature", TMessageType.CALL, callback);
      this.featureMd5 = featureMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.featureMd5 != null) {
        protocol.writeFieldBegin("featureMd5", 1, TType.STRING);
        protocol.writeString(this.featureMd5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<FaceBean> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<FaceBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<FaceBean> value = new ArrayList<FaceBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.FaceBean item0 = net.gdface.facelog.client.thrift.FaceBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFacesOfImageCall extends MethodCall<List<FaceBean>> {
    private final String imageMd5;

    GetFacesOfImageCall(String imageMd5, ServiceMethodCallback<List<FaceBean>> callback) {
      super("getFacesOfImage", TMessageType.CALL, callback);
      this.imageMd5 = imageMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.imageMd5 != null) {
        protocol.writeFieldBegin("imageMd5", 1, TType.STRING);
        protocol.writeString(this.imageMd5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<FaceBean> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<FaceBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<FaceBean> value = new ArrayList<FaceBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.FaceBean item0 = net.gdface.facelog.client.thrift.FaceBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeatureCall extends MethodCall<FeatureBean> {
    private final String md5;

    GetFeatureCall(String md5, ServiceMethodCallback<FeatureBean> callback) {
      super("getFeature", TMessageType.CALL, callback);
      this.md5 = md5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.md5 != null) {
        protocol.writeFieldBegin("md5", 1, TType.STRING);
        protocol.writeString(this.md5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected FeatureBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      FeatureBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.FeatureBean value = net.gdface.facelog.client.thrift.FeatureBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeatureBytesCall extends MethodCall<ByteString> {
    private final String md5;

    GetFeatureBytesCall(String md5, ServiceMethodCallback<ByteString> callback) {
      super("getFeatureBytes", TMessageType.CALL, callback);
      this.md5 = md5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.md5 != null) {
        protocol.writeFieldBegin("md5", 1, TType.STRING);
        protocol.writeString(this.md5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected ByteString receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ByteString result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              ByteString value = protocol.readBinary();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeatureBytesListCall extends MethodCall<List<ByteString>> {
    private final List<String> md5List;

    private final Boolean truncation;

    GetFeatureBytesListCall(List<String> md5List, Boolean truncation,
        ServiceMethodCallback<List<ByteString>> callback) {
      super("getFeatureBytesList", TMessageType.CALL, callback);
      this.md5List = md5List;
      if (truncation == null) throw new NullPointerException("truncation");
      this.truncation = truncation;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.md5List != null) {
        protocol.writeFieldBegin("md5List", 1, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.md5List.size());
        for (String item0 : this.md5List) {
          protocol.writeString(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("truncation", 2, TType.BOOL);
      protocol.writeBool(this.truncation);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<ByteString> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<ByteString> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<ByteString> value = new ArrayList<ByteString>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                ByteString item0 = protocol.readBinary();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeatureBytesTruncationCall extends MethodCall<ByteString> {
    private final String md5;

    private final Boolean truncation;

    GetFeatureBytesTruncationCall(String md5, Boolean truncation,
        ServiceMethodCallback<ByteString> callback) {
      super("getFeatureBytesTruncation", TMessageType.CALL, callback);
      this.md5 = md5;
      if (truncation == null) throw new NullPointerException("truncation");
      this.truncation = truncation;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.md5 != null) {
        protocol.writeFieldBegin("md5", 1, TType.STRING);
        protocol.writeString(this.md5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("truncation", 2, TType.BOOL);
      protocol.writeBool(this.truncation);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected ByteString receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ByteString result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              ByteString value = protocol.readBinary();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeaturesCall extends MethodCall<List<FeatureBean>> {
    private final List<String> md5List;

    GetFeaturesCall(List<String> md5List, ServiceMethodCallback<List<FeatureBean>> callback) {
      super("getFeatures", TMessageType.CALL, callback);
      this.md5List = md5List;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.md5List != null) {
        protocol.writeFieldBegin("md5List", 1, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.md5List.size());
        for (String item0 : this.md5List) {
          protocol.writeString(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<FeatureBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<FeatureBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<FeatureBean> value = new ArrayList<FeatureBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.FeatureBean item0 = net.gdface.facelog.client.thrift.FeatureBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeaturesByPersonIdAndSdkVersionCall extends MethodCall<List<String>> {
    private final Integer personId;

    private final String sdkVersion;

    GetFeaturesByPersonIdAndSdkVersionCall(Integer personId, String sdkVersion,
        ServiceMethodCallback<List<String>> callback) {
      super("getFeaturesByPersonIdAndSdkVersion", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.sdkVersion = sdkVersion;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.sdkVersion != null) {
        protocol.writeFieldBegin("sdkVersion", 2, TType.STRING);
        protocol.writeString(this.sdkVersion);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeaturesOfImageCall extends MethodCall<List<String>> {
    private final String imageMd5;

    GetFeaturesOfImageCall(String imageMd5, ServiceMethodCallback<List<String>> callback) {
      super("getFeaturesOfImage", TMessageType.CALL, callback);
      this.imageMd5 = imageMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.imageMd5 != null) {
        protocol.writeFieldBegin("imageMd5", 1, TType.STRING);
        protocol.writeString(this.imageMd5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeaturesOfPersonCall extends MethodCall<List<String>> {
    private final Integer personId;

    GetFeaturesOfPersonCall(Integer personId, ServiceMethodCallback<List<String>> callback) {
      super("getFeaturesOfPerson", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetFeaturesPermittedOnDeviceCall extends MethodCall<List<String>> {
    private final Integer deviceId;

    private final Boolean ignoreSchedule;

    private final String sdkVersion;

    private final List<String> excludeFeatureIds;

    private final Long timestamp;

    GetFeaturesPermittedOnDeviceCall(Integer deviceId, Boolean ignoreSchedule, String sdkVersion,
        List<String> excludeFeatureIds, Long timestamp,
        ServiceMethodCallback<List<String>> callback) {
      super("getFeaturesPermittedOnDevice", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
      if (ignoreSchedule == null) throw new NullPointerException("ignoreSchedule");
      this.ignoreSchedule = ignoreSchedule;
      this.sdkVersion = sdkVersion;
      this.excludeFeatureIds = excludeFeatureIds;
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("ignoreSchedule", 2, TType.BOOL);
      protocol.writeBool(this.ignoreSchedule);
      protocol.writeFieldEnd();
      if (this.sdkVersion != null) {
        protocol.writeFieldBegin("sdkVersion", 3, TType.STRING);
        protocol.writeString(this.sdkVersion);
        protocol.writeFieldEnd();
      }
      if (this.excludeFeatureIds != null) {
        protocol.writeFieldBegin("excludeFeatureIds", 4, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.excludeFeatureIds.size());
        for (String item0 : this.excludeFeatureIds) {
          protocol.writeString(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 5, TType.I64);
        protocol.writeI64(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetGroupPermitCall extends MethodCall<PermitBean> {
    private final Integer deviceId;

    private final Integer personGroupId;

    GetGroupPermitCall(Integer deviceId, Integer personGroupId,
        ServiceMethodCallback<PermitBean> callback) {
      super("getGroupPermit", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("personGroupId", 2, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PermitBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PermitBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PermitBean value = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetGroupPermitOnDeviceGroupCall extends MethodCall<PermitBean> {
    private final Integer deviceGroupId;

    private final Integer personGroupId;

    GetGroupPermitOnDeviceGroupCall(Integer deviceGroupId, Integer personGroupId,
        ServiceMethodCallback<PermitBean> callback) {
      super("getGroupPermitOnDeviceGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("personGroupId", 2, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PermitBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PermitBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PermitBean value = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetGroupPermitsCall extends MethodCall<List<PermitBean>> {
    private final Integer deviceId;

    private final List<Integer> personGroupIdList;

    GetGroupPermitsCall(Integer deviceId, List<Integer> personGroupIdList,
        ServiceMethodCallback<List<PermitBean>> callback) {
      super("getGroupPermits", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
      this.personGroupIdList = personGroupIdList;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      if (this.personGroupIdList != null) {
        protocol.writeFieldBegin("personGroupIdList", 2, TType.LIST);
        protocol.writeListBegin(TType.I32, this.personGroupIdList.size());
        for (Integer item0 : this.personGroupIdList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PermitBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PermitBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PermitBean> value = new ArrayList<PermitBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PermitBean item0 = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetImageCall extends MethodCall<ImageBean> {
    private final String imageMD5;

    GetImageCall(String imageMD5, ServiceMethodCallback<ImageBean> callback) {
      super("getImage", TMessageType.CALL, callback);
      this.imageMD5 = imageMD5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.imageMD5 != null) {
        protocol.writeFieldBegin("imageMD5", 1, TType.STRING);
        protocol.writeString(this.imageMD5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected ImageBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ImageBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ImageBean value = net.gdface.facelog.client.thrift.ImageBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetImageBytesCall extends MethodCall<ByteString> {
    private final String imageMD5;

    GetImageBytesCall(String imageMD5, ServiceMethodCallback<ByteString> callback) {
      super("getImageBytes", TMessageType.CALL, callback);
      this.imageMD5 = imageMD5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.imageMD5 != null) {
        protocol.writeFieldBegin("imageMD5", 1, TType.STRING);
        protocol.writeString(this.imageMD5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected ByteString receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ByteString result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              ByteString value = protocol.readBinary();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetImageBytesRefCall extends MethodCall<ByteString> {
    private final String primaryKey;

    private final String refType;

    GetImageBytesRefCall(String primaryKey, String refType,
        ServiceMethodCallback<ByteString> callback) {
      super("getImageBytesRef", TMessageType.CALL, callback);
      this.primaryKey = primaryKey;
      this.refType = refType;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.primaryKey != null) {
        protocol.writeFieldBegin("primaryKey", 1, TType.STRING);
        protocol.writeString(this.primaryKey);
        protocol.writeFieldEnd();
      }
      if (this.refType != null) {
        protocol.writeFieldBegin("refType", 2, TType.STRING);
        protocol.writeString(this.refType);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected ByteString receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ByteString result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              ByteString value = protocol.readBinary();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetImageRefCall extends MethodCall<ImageBean> {
    private final String primaryKey;

    private final String refType;

    GetImageRefCall(String primaryKey, String refType, ServiceMethodCallback<ImageBean> callback) {
      super("getImageRef", TMessageType.CALL, callback);
      this.primaryKey = primaryKey;
      this.refType = refType;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.primaryKey != null) {
        protocol.writeFieldBegin("primaryKey", 1, TType.STRING);
        protocol.writeString(this.primaryKey);
        protocol.writeFieldEnd();
      }
      if (this.refType != null) {
        protocol.writeFieldBegin("refType", 2, TType.STRING);
        protocol.writeString(this.refType);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected ImageBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ImageBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ImageBean value = net.gdface.facelog.client.thrift.ImageBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetImagesAssociatedByFeatureCall extends MethodCall<List<String>> {
    private final String featureMd5;

    GetImagesAssociatedByFeatureCall(String featureMd5,
        ServiceMethodCallback<List<String>> callback) {
      super("getImagesAssociatedByFeature", TMessageType.CALL, callback);
      this.featureMd5 = featureMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.featureMd5 != null) {
        protocol.writeFieldBegin("featureMd5", 1, TType.STRING);
        protocol.writeString(this.featureMd5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetLogBeansByPersonIdCall extends MethodCall<List<LogBean>> {
    private final Integer personId;

    GetLogBeansByPersonIdCall(Integer personId, ServiceMethodCallback<List<LogBean>> callback) {
      super("getLogBeansByPersonId", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<LogBean> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<LogBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<LogBean> value = new ArrayList<LogBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.LogBean item0 = net.gdface.facelog.client.thrift.LogBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetMessageQueueParametersCall extends MethodCall<Map<MQParam, String>> {
    private final Token token;

    GetMessageQueueParametersCall(Token token,
        ServiceMethodCallback<Map<MQParam, String>> callback) {
      super("getMessageQueueParameters", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<MQParam, String> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<MQParam, String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<MQParam, String> value = new HashMap<MQParam, String>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                int i32_1 = protocol.readI32();
                net.gdface.facelog.client.thrift.MQParam key0 = net.gdface.facelog.client.thrift.MQParam.findByValue(i32_1);
                if (key0 == null) {
                  throw new ThriftException(ThriftException.Kind.PROTOCOL_ERROR, "Unexpected value for enum-type MQParam: " + i32_1);
                }
                String value0 = protocol.readString();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonCall extends MethodCall<PersonBean> {
    private final Integer personId;

    GetPersonCall(Integer personId, ServiceMethodCallback<PersonBean> callback) {
      super("getPerson", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonByMobilePhoneCall extends MethodCall<PersonBean> {
    private final String mobilePhone;

    GetPersonByMobilePhoneCall(String mobilePhone, ServiceMethodCallback<PersonBean> callback) {
      super("getPersonByMobilePhone", TMessageType.CALL, callback);
      this.mobilePhone = mobilePhone;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.mobilePhone != null) {
        protocol.writeFieldBegin("mobilePhone", 1, TType.STRING);
        protocol.writeString(this.mobilePhone);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonByMobilePhoneRealCall extends MethodCall<PersonBean> {
    private final String mobilePhone;

    private final Token token;

    GetPersonByMobilePhoneRealCall(String mobilePhone, Token token,
        ServiceMethodCallback<PersonBean> callback) {
      super("getPersonByMobilePhoneReal", TMessageType.CALL, callback);
      this.mobilePhone = mobilePhone;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.mobilePhone != null) {
        protocol.writeFieldBegin("mobilePhone", 1, TType.STRING);
        protocol.writeString(this.mobilePhone);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonByPapersNumCall extends MethodCall<PersonBean> {
    private final String papersNum;

    GetPersonByPapersNumCall(String papersNum, ServiceMethodCallback<PersonBean> callback) {
      super("getPersonByPapersNum", TMessageType.CALL, callback);
      this.papersNum = papersNum;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.papersNum != null) {
        protocol.writeFieldBegin("papersNum", 1, TType.STRING);
        protocol.writeString(this.papersNum);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonByPapersNumRealCall extends MethodCall<PersonBean> {
    private final String papersNum;

    private final Token token;

    GetPersonByPapersNumRealCall(String papersNum, Token token,
        ServiceMethodCallback<PersonBean> callback) {
      super("getPersonByPapersNumReal", TMessageType.CALL, callback);
      this.papersNum = papersNum;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.papersNum != null) {
        protocol.writeFieldBegin("papersNum", 1, TType.STRING);
        protocol.writeString(this.papersNum);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonGroupCall extends MethodCall<PersonGroupBean> {
    private final Integer personGroupId;

    GetPersonGroupCall(Integer personGroupId, ServiceMethodCallback<PersonGroupBean> callback) {
      super("getPersonGroup", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonGroupBean receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      PersonGroupBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonGroupBean value = net.gdface.facelog.client.thrift.PersonGroupBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonGroupsCall extends MethodCall<List<PersonGroupBean>> {
    private final List<Integer> groupIdList;

    GetPersonGroupsCall(List<Integer> groupIdList,
        ServiceMethodCallback<List<PersonGroupBean>> callback) {
      super("getPersonGroups", TMessageType.CALL, callback);
      this.groupIdList = groupIdList;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.groupIdList != null) {
        protocol.writeFieldBegin("groupIdList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.groupIdList.size());
        for (Integer item0 : this.groupIdList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PersonGroupBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PersonGroupBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PersonGroupBean> value = new ArrayList<PersonGroupBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PersonGroupBean item0 = net.gdface.facelog.client.thrift.PersonGroupBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonGroupsBelongsCall extends MethodCall<List<Integer>> {
    private final Integer personId;

    GetPersonGroupsBelongsCall(Integer personId, ServiceMethodCallback<List<Integer>> callback) {
      super("getPersonGroupsBelongs", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonGroupsPermittedByCall extends MethodCall<List<Integer>> {
    private final Integer deviceGroupId;

    GetPersonGroupsPermittedByCall(Integer deviceGroupId,
        ServiceMethodCallback<List<Integer>> callback) {
      super("getPersonGroupsPermittedBy", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonPermitCall extends MethodCall<PermitBean> {
    private final Integer deviceId;

    private final Integer personId;

    GetPersonPermitCall(Integer deviceId, Integer personId,
        ServiceMethodCallback<PermitBean> callback) {
      super("getPersonPermit", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("personId", 2, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PermitBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PermitBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PermitBean value = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonPermitsCall extends MethodCall<List<PermitBean>> {
    private final Integer deviceId;

    private final List<Integer> personIdList;

    GetPersonPermitsCall(Integer deviceId, List<Integer> personIdList,
        ServiceMethodCallback<List<PermitBean>> callback) {
      super("getPersonPermits", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
      this.personIdList = personIdList;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      if (this.personIdList != null) {
        protocol.writeFieldBegin("personIdList", 2, TType.LIST);
        protocol.writeListBegin(TType.I32, this.personIdList.size());
        for (Integer item0 : this.personIdList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PermitBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PermitBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PermitBean> value = new ArrayList<PermitBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PermitBean item0 = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonRealCall extends MethodCall<PersonBean> {
    private final Integer personId;

    private final Token token;

    GetPersonRealCall(Integer personId, Token token, ServiceMethodCallback<PersonBean> callback) {
      super("getPersonReal", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonsCall extends MethodCall<List<PersonBean>> {
    private final List<Integer> idList;

    GetPersonsCall(List<Integer> idList, ServiceMethodCallback<List<PersonBean>> callback) {
      super("getPersons", TMessageType.CALL, callback);
      this.idList = idList;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.idList != null) {
        protocol.writeFieldBegin("idList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.idList.size());
        for (Integer item0 : this.idList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PersonBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PersonBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PersonBean> value = new ArrayList<PersonBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PersonBean item0 = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonsOfGroupCall extends MethodCall<List<Integer>> {
    private final Integer personGroupId;

    GetPersonsOfGroupCall(Integer personGroupId, ServiceMethodCallback<List<Integer>> callback) {
      super("getPersonsOfGroup", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonsPermittedOnDeviceCall extends MethodCall<List<Integer>> {
    private final Integer deviceId;

    private final Boolean ignoreSchedule;

    private final List<Integer> excludePersonIds;

    private final Long timestamp;

    GetPersonsPermittedOnDeviceCall(Integer deviceId, Boolean ignoreSchedule,
        List<Integer> excludePersonIds, Long timestamp,
        ServiceMethodCallback<List<Integer>> callback) {
      super("getPersonsPermittedOnDevice", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
      if (ignoreSchedule == null) throw new NullPointerException("ignoreSchedule");
      this.ignoreSchedule = ignoreSchedule;
      this.excludePersonIds = excludePersonIds;
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("ignoreSchedule", 2, TType.BOOL);
      protocol.writeBool(this.ignoreSchedule);
      protocol.writeFieldEnd();
      if (this.excludePersonIds != null) {
        protocol.writeFieldBegin("excludePersonIds", 3, TType.LIST);
        protocol.writeListBegin(TType.I32, this.excludePersonIds.size());
        for (Integer item0 : this.excludePersonIds) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 4, TType.I64);
        protocol.writeI64(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPersonsRealCall extends MethodCall<List<PersonBean>> {
    private final List<Integer> idList;

    private final Token token;

    GetPersonsRealCall(List<Integer> idList, Token token,
        ServiceMethodCallback<List<PersonBean>> callback) {
      super("getPersonsReal", TMessageType.CALL, callback);
      this.idList = idList;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.idList != null) {
        protocol.writeFieldBegin("idList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.idList.size());
        for (Integer item0 : this.idList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PersonBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PersonBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PersonBean> value = new ArrayList<PersonBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PersonBean item0 = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPropertiesCall extends MethodCall<Map<String, String>> {
    private final String prefix;

    private final Token token;

    GetPropertiesCall(String prefix, Token token,
        ServiceMethodCallback<Map<String, String>> callback) {
      super("getProperties", TMessageType.CALL, callback);
      this.prefix = prefix;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.prefix != null) {
        protocol.writeFieldBegin("prefix", 1, TType.STRING);
        protocol.writeString(this.prefix);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<String, String> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<String, String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<String, String> value = new HashMap<String, String>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                String key0 = protocol.readString();
                String value0 = protocol.readString();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetPropertyCall extends MethodCall<String> {
    private final String key;

    private final Token token;

    GetPropertyCall(String key, Token token, ServiceMethodCallback<String> callback) {
      super("getProperty", TMessageType.CALL, callback);
      this.key = key;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.key != null) {
        protocol.writeFieldBegin("key", 1, TType.STRING);
        protocol.writeString(this.key);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetRedisParametersCall extends MethodCall<Map<MQParam, String>> {
    private final Token token;

    GetRedisParametersCall(Token token, ServiceMethodCallback<Map<MQParam, String>> callback) {
      super("getRedisParameters", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<MQParam, String> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<MQParam, String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<MQParam, String> value = new HashMap<MQParam, String>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                int i32_1 = protocol.readI32();
                net.gdface.facelog.client.thrift.MQParam key0 = net.gdface.facelog.client.thrift.MQParam.findByValue(i32_1);
                if (key0 == null) {
                  throw new ThriftException(ThriftException.Kind.PROTOCOL_ERROR, "Unexpected value for enum-type MQParam: " + i32_1);
                }
                String value0 = protocol.readString();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetServiceConfigCall extends MethodCall<Map<String, String>> {
    private final Token token;

    GetServiceConfigCall(Token token, ServiceMethodCallback<Map<String, String>> callback) {
      super("getServiceConfig", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<String, String> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<String, String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<String, String> value = new HashMap<String, String>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                String key0 = protocol.readString();
                String value0 = protocol.readString();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetSubDeviceGroupCall extends MethodCall<List<Integer>> {
    private final Integer deviceGroupId;

    GetSubDeviceGroupCall(Integer deviceGroupId, ServiceMethodCallback<List<Integer>> callback) {
      super("getSubDeviceGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetSubPersonGroupCall extends MethodCall<List<Integer>> {
    private final Integer personGroupId;

    GetSubPersonGroupCall(Integer personGroupId, ServiceMethodCallback<List<Integer>> callback) {
      super("getSubPersonGroup", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class GetTargetInfo4PwdOnDeviceCall extends MethodCall<TmpwdTargetInfo> {
    private final String pwd;

    private final Token token;

    GetTargetInfo4PwdOnDeviceCall(String pwd, Token token,
        ServiceMethodCallback<TmpwdTargetInfo> callback) {
      super("getTargetInfo4PwdOnDevice", TMessageType.CALL, callback);
      this.pwd = pwd;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.pwd != null) {
        protocol.writeFieldBegin("pwd", 1, TType.STRING);
        protocol.writeString(this.pwd);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected TmpwdTargetInfo receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      TmpwdTargetInfo result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.TmpwdTargetInfo value = net.gdface.facelog.client.thrift.TmpwdTargetInfo.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class InitTopGroupCall extends MethodCall<Integer> {
    private final TopGroupInfo groupInfo;

    private final Token token;

    InitTopGroupCall(TopGroupInfo groupInfo, Token token, ServiceMethodCallback<Integer> callback) {
      super("initTopGroup", TMessageType.CALL, callback);
      this.groupInfo = groupInfo;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.groupInfo != null) {
        protocol.writeFieldBegin("groupInfo", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.TopGroupInfo.ADAPTER.write(protocol, this.groupInfo);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsDisableCall extends MethodCall<Boolean> {
    private final Integer personId;

    IsDisableCall(Integer personId, ServiceMethodCallback<Boolean> callback) {
      super("isDisable", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsLocalCall extends MethodCall<Boolean> {
    IsLocalCall(ServiceMethodCallback<Boolean> callback) {
      super("isLocal", TMessageType.CALL, callback);
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidAckChannelCall extends MethodCall<Boolean> {
    private final String ackChannel;

    IsValidAckChannelCall(String ackChannel, ServiceMethodCallback<Boolean> callback) {
      super("isValidAckChannel", TMessageType.CALL, callback);
      this.ackChannel = ackChannel;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.ackChannel != null) {
        protocol.writeFieldBegin("ackChannel", 1, TType.STRING);
        protocol.writeString(this.ackChannel);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidCmdSnCall extends MethodCall<Boolean> {
    private final Integer cmdSn;

    IsValidCmdSnCall(Integer cmdSn, ServiceMethodCallback<Boolean> callback) {
      super("isValidCmdSn", TMessageType.CALL, callback);
      if (cmdSn == null) throw new NullPointerException("cmdSn");
      this.cmdSn = cmdSn;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("cmdSn", 1, TType.I32);
      protocol.writeI32(this.cmdSn);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidDeviceTokenCall extends MethodCall<Boolean> {
    private final Token token;

    IsValidDeviceTokenCall(Token token, ServiceMethodCallback<Boolean> callback) {
      super("isValidDeviceToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidPasswordCall extends MethodCall<Boolean> {
    private final String userId;

    private final String password;

    private final Boolean isMd5;

    IsValidPasswordCall(String userId, String password, Boolean isMd5,
        ServiceMethodCallback<Boolean> callback) {
      super("isValidPassword", TMessageType.CALL, callback);
      this.userId = userId;
      this.password = password;
      if (isMd5 == null) throw new NullPointerException("isMd5");
      this.isMd5 = isMd5;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.userId != null) {
        protocol.writeFieldBegin("userId", 1, TType.STRING);
        protocol.writeString(this.userId);
        protocol.writeFieldEnd();
      }
      if (this.password != null) {
        protocol.writeFieldBegin("password", 2, TType.STRING);
        protocol.writeString(this.password);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("isMd5", 3, TType.BOOL);
      protocol.writeBool(this.isMd5);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidPersonTokenCall extends MethodCall<Boolean> {
    private final Token token;

    IsValidPersonTokenCall(Token token, ServiceMethodCallback<Boolean> callback) {
      super("isValidPersonToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidRootTokenCall extends MethodCall<Boolean> {
    private final Token token;

    IsValidRootTokenCall(Token token, ServiceMethodCallback<Boolean> callback) {
      super("isValidRootToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidTokenCall extends MethodCall<Boolean> {
    private final Token token;

    IsValidTokenCall(Token token, ServiceMethodCallback<Boolean> callback) {
      super("isValidToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class IsValidUserTokenCall extends MethodCall<Boolean> {
    private final Token token;

    IsValidUserTokenCall(Token token, ServiceMethodCallback<Boolean> callback) {
      super("isValidUserToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Boolean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Boolean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.BOOL) {
              boolean value = protocol.readBool();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class Iso8601TimeCall extends MethodCall<String> {
    Iso8601TimeCall(ServiceMethodCallback<String> callback) {
      super("iso8601Time", TMessageType.CALL, callback);
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ListOfParentForDeviceGroupCall extends MethodCall<List<Integer>> {
    private final Integer deviceGroupId;

    ListOfParentForDeviceGroupCall(Integer deviceGroupId,
        ServiceMethodCallback<List<Integer>> callback) {
      super("listOfParentForDeviceGroup", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ListOfParentForPersonGroupCall extends MethodCall<List<Integer>> {
    private final Integer personGroupId;

    ListOfParentForPersonGroupCall(Integer personGroupId,
        ServiceMethodCallback<List<Integer>> callback) {
      super("listOfParentForPersonGroup", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadAllPersonCall extends MethodCall<List<Integer>> {
    LoadAllPersonCall(ServiceMethodCallback<List<Integer>> callback) {
      super("loadAllPerson", TMessageType.CALL, callback);
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadDeviceByWhereCall extends MethodCall<List<DeviceBean>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    LoadDeviceByWhereCall(String where, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<DeviceBean>> callback) {
      super("loadDeviceByWhere", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<DeviceBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<DeviceBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<DeviceBean> value = new ArrayList<DeviceBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.DeviceBean item0 = net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadDeviceGroupByWhereCall extends MethodCall<List<Integer>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    LoadDeviceGroupByWhereCall(String where, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<Integer>> callback) {
      super("loadDeviceGroupByWhere", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadDeviceGroupIdByWhereCall extends MethodCall<List<Integer>> {
    private final String where;

    LoadDeviceGroupIdByWhereCall(String where, ServiceMethodCallback<List<Integer>> callback) {
      super("loadDeviceGroupIdByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadDeviceIdByWhereCall extends MethodCall<List<Integer>> {
    private final String where;

    LoadDeviceIdByWhereCall(String where, ServiceMethodCallback<List<Integer>> callback) {
      super("loadDeviceIdByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadDistinctIntegerColumnCall extends MethodCall<List<Integer>> {
    private final String table;

    private final String column;

    private final String where;

    LoadDistinctIntegerColumnCall(String table, String column, String where,
        ServiceMethodCallback<List<Integer>> callback) {
      super("loadDistinctIntegerColumn", TMessageType.CALL, callback);
      this.table = table;
      this.column = column;
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.table != null) {
        protocol.writeFieldBegin("table", 1, TType.STRING);
        protocol.writeString(this.table);
        protocol.writeFieldEnd();
      }
      if (this.column != null) {
        protocol.writeFieldBegin("column", 2, TType.STRING);
        protocol.writeString(this.column);
        protocol.writeFieldEnd();
      }
      if (this.where != null) {
        protocol.writeFieldBegin("where", 3, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadDistinctStringColumnCall extends MethodCall<List<String>> {
    private final String table;

    private final String column;

    private final String where;

    LoadDistinctStringColumnCall(String table, String column, String where,
        ServiceMethodCallback<List<String>> callback) {
      super("loadDistinctStringColumn", TMessageType.CALL, callback);
      this.table = table;
      this.column = column;
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.table != null) {
        protocol.writeFieldBegin("table", 1, TType.STRING);
        protocol.writeString(this.table);
        protocol.writeFieldEnd();
      }
      if (this.column != null) {
        protocol.writeFieldBegin("column", 2, TType.STRING);
        protocol.writeString(this.column);
        protocol.writeFieldEnd();
      }
      if (this.where != null) {
        protocol.writeFieldBegin("where", 3, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadErrorLogByWhereCall extends MethodCall<List<ErrorLogBean>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    LoadErrorLogByWhereCall(String where, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<ErrorLogBean>> callback) {
      super("loadErrorLogByWhere", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<ErrorLogBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<ErrorLogBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<ErrorLogBean> value = new ArrayList<ErrorLogBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.ErrorLogBean item0 = net.gdface.facelog.client.thrift.ErrorLogBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadFeatureMd5ByUpdateCall extends MethodCall<List<String>> {
    private final Long timestamp;

    LoadFeatureMd5ByUpdateCall(Long timestamp, ServiceMethodCallback<List<String>> callback) {
      super("loadFeatureMd5ByUpdate", TMessageType.CALL, callback);
      if (timestamp == null) throw new NullPointerException("timestamp");
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("timestamp", 1, TType.I64);
      protocol.writeI64(this.timestamp);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadFeatureMd5ByUpdateTimeStrCall extends MethodCall<List<String>> {
    private final String timestamp;

    LoadFeatureMd5ByUpdateTimeStrCall(String timestamp,
        ServiceMethodCallback<List<String>> callback) {
      super("loadFeatureMd5ByUpdateTimeStr", TMessageType.CALL, callback);
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 1, TType.STRING);
        protocol.writeString(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<String> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<String> value = new ArrayList<String>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                String item0 = protocol.readString();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadLogByWhereCall extends MethodCall<List<LogBean>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    LoadLogByWhereCall(String where, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<LogBean>> callback) {
      super("loadLogByWhere", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<LogBean> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<LogBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<LogBean> value = new ArrayList<LogBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.LogBean item0 = net.gdface.facelog.client.thrift.LogBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadLogLightByVerifyTimeCall extends MethodCall<List<LogLightBean>> {
    private final Long timestamp;

    private final Integer startRow;

    private final Integer numRows;

    LoadLogLightByVerifyTimeCall(Long timestamp, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<LogLightBean>> callback) {
      super("loadLogLightByVerifyTime", TMessageType.CALL, callback);
      if (timestamp == null) throw new NullPointerException("timestamp");
      this.timestamp = timestamp;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("timestamp", 1, TType.I64);
      protocol.writeI64(this.timestamp);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<LogLightBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<LogLightBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<LogLightBean> value = new ArrayList<LogLightBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.LogLightBean item0 = net.gdface.facelog.client.thrift.LogLightBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadLogLightByVerifyTimeTimestrCall extends MethodCall<List<LogLightBean>> {
    private final String timestamp;

    private final Integer startRow;

    private final Integer numRows;

    LoadLogLightByVerifyTimeTimestrCall(String timestamp, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<LogLightBean>> callback) {
      super("loadLogLightByVerifyTimeTimestr", TMessageType.CALL, callback);
      this.timestamp = timestamp;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 1, TType.STRING);
        protocol.writeString(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<LogLightBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<LogLightBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<LogLightBean> value = new ArrayList<LogLightBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.LogLightBean item0 = net.gdface.facelog.client.thrift.LogLightBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadLogLightByWhereCall extends MethodCall<List<LogLightBean>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    LoadLogLightByWhereCall(String where, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<LogLightBean>> callback) {
      super("loadLogLightByWhere", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<LogLightBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<LogLightBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<LogLightBean> value = new ArrayList<LogLightBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.LogLightBean item0 = net.gdface.facelog.client.thrift.LogLightBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPermitByUpdateCall extends MethodCall<List<PermitBean>> {
    private final Long timestamp;

    LoadPermitByUpdateCall(Long timestamp, ServiceMethodCallback<List<PermitBean>> callback) {
      super("loadPermitByUpdate", TMessageType.CALL, callback);
      if (timestamp == null) throw new NullPointerException("timestamp");
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("timestamp", 1, TType.I64);
      protocol.writeI64(this.timestamp);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PermitBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PermitBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PermitBean> value = new ArrayList<PermitBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PermitBean item0 = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPermitByUpdateTimestrCall extends MethodCall<List<PermitBean>> {
    private final String timestamp;

    LoadPermitByUpdateTimestrCall(String timestamp,
        ServiceMethodCallback<List<PermitBean>> callback) {
      super("loadPermitByUpdateTimestr", TMessageType.CALL, callback);
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 1, TType.STRING);
        protocol.writeString(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PermitBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PermitBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PermitBean> value = new ArrayList<PermitBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PermitBean item0 = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPersonByWhereCall extends MethodCall<List<PersonBean>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    LoadPersonByWhereCall(String where, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<PersonBean>> callback) {
      super("loadPersonByWhere", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PersonBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PersonBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PersonBean> value = new ArrayList<PersonBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PersonBean item0 = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPersonByWhereRealCall extends MethodCall<List<PersonBean>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    private final Token token;

    LoadPersonByWhereRealCall(String where, Integer startRow, Integer numRows, Token token,
        ServiceMethodCallback<List<PersonBean>> callback) {
      super("loadPersonByWhereReal", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<PersonBean> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      List<PersonBean> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<PersonBean> value = new ArrayList<PersonBean>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                net.gdface.facelog.client.thrift.PersonBean item0 = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPersonGroupByWhereCall extends MethodCall<List<Integer>> {
    private final String where;

    private final Integer startRow;

    private final Integer numRows;

    LoadPersonGroupByWhereCall(String where, Integer startRow, Integer numRows,
        ServiceMethodCallback<List<Integer>> callback) {
      super("loadPersonGroupByWhere", TMessageType.CALL, callback);
      this.where = where;
      if (startRow == null) throw new NullPointerException("startRow");
      this.startRow = startRow;
      if (numRows == null) throw new NullPointerException("numRows");
      this.numRows = numRows;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("startRow", 2, TType.I32);
      protocol.writeI32(this.startRow);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("numRows", 3, TType.I32);
      protocol.writeI32(this.numRows);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPersonGroupIdByWhereCall extends MethodCall<List<Integer>> {
    private final String where;

    LoadPersonGroupIdByWhereCall(String where, ServiceMethodCallback<List<Integer>> callback) {
      super("loadPersonGroupIdByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPersonIdByUpdateTimeCall extends MethodCall<List<Integer>> {
    private final Long timestamp;

    LoadPersonIdByUpdateTimeCall(Long timestamp, ServiceMethodCallback<List<Integer>> callback) {
      super("loadPersonIdByUpdateTime", TMessageType.CALL, callback);
      if (timestamp == null) throw new NullPointerException("timestamp");
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("timestamp", 1, TType.I64);
      protocol.writeI64(this.timestamp);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPersonIdByUpdateTimeTimeStrCall extends MethodCall<List<Integer>> {
    private final String timestamp;

    LoadPersonIdByUpdateTimeTimeStrCall(String timestamp,
        ServiceMethodCallback<List<Integer>> callback) {
      super("loadPersonIdByUpdateTimeTimeStr", TMessageType.CALL, callback);
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 1, TType.STRING);
        protocol.writeString(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadPersonIdByWhereCall extends MethodCall<List<Integer>> {
    private final String where;

    LoadPersonIdByWhereCall(String where, ServiceMethodCallback<List<Integer>> callback) {
      super("loadPersonIdByWhere", TMessageType.CALL, callback);
      this.where = where;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.where != null) {
        protocol.writeFieldBegin("where", 1, TType.STRING);
        protocol.writeString(this.where);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadUpdatedPersonsCall extends MethodCall<List<Integer>> {
    private final Long timestamp;

    LoadUpdatedPersonsCall(Long timestamp, ServiceMethodCallback<List<Integer>> callback) {
      super("loadUpdatedPersons", TMessageType.CALL, callback);
      if (timestamp == null) throw new NullPointerException("timestamp");
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("timestamp", 1, TType.I64);
      protocol.writeI64(this.timestamp);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LoadUpdatedPersonsTimestrCall extends MethodCall<List<Integer>> {
    private final String timestamp;

    LoadUpdatedPersonsTimestrCall(String timestamp, ServiceMethodCallback<List<Integer>> callback) {
      super("loadUpdatedPersonsTimestr", TMessageType.CALL, callback);
      this.timestamp = timestamp;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.timestamp != null) {
        protocol.writeFieldBegin("timestamp", 1, TType.STRING);
        protocol.writeString(this.timestamp);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected List<Integer> receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      List<Integer> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.LIST) {
              ListMetadata listMetadata0 = protocol.readListBegin();
              List<Integer> value = new ArrayList<Integer>(listMetadata0.size);
              for (int i0 = 0; i0 < listMetadata0.size; ++i0) {
                int item0 = protocol.readI32();
                value.add(item0);
              }
              protocol.readListEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class LockWakeupCall extends MethodCall<LockWakeupResponse> {
    private final DeviceBean deviceBean;

    private final Boolean ignoreSchedule;

    private final String sdkVersion;

    LockWakeupCall(DeviceBean deviceBean, Boolean ignoreSchedule, String sdkVersion,
        ServiceMethodCallback<LockWakeupResponse> callback) {
      super("lockWakeup", TMessageType.CALL, callback);
      this.deviceBean = deviceBean;
      if (ignoreSchedule == null) throw new NullPointerException("ignoreSchedule");
      this.ignoreSchedule = ignoreSchedule;
      this.sdkVersion = sdkVersion;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.deviceBean != null) {
        protocol.writeFieldBegin("deviceBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.write(protocol, this.deviceBean);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("ignoreSchedule", 2, TType.BOOL);
      protocol.writeBool(this.ignoreSchedule);
      protocol.writeFieldEnd();
      if (this.sdkVersion != null) {
        protocol.writeFieldBegin("sdkVersion", 3, TType.STRING);
        protocol.writeString(this.sdkVersion);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected LockWakeupResponse receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      LockWakeupResponse result = null;
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.LockWakeupResponse value = net.gdface.facelog.client.thrift.LockWakeupResponse.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class OfflineCall extends MethodCall<Void> {
    private final Token token;

    OfflineCall(Token token, ServiceMethodCallback<Void> callback) {
      super("offline", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class OnlineCall extends MethodCall<Token> {
    private final DeviceBean device;

    OnlineCall(DeviceBean device, ServiceMethodCallback<Token> callback) {
      super("online", TMessageType.CALL, callback);
      this.device = device;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.device != null) {
        protocol.writeFieldBegin("device", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.write(protocol, this.device);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Token receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Token result = null;
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.Token value = net.gdface.facelog.client.thrift.Token.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class RegisterDeviceCall extends MethodCall<DeviceBean> {
    private final DeviceBean newDevice;

    RegisterDeviceCall(DeviceBean newDevice, ServiceMethodCallback<DeviceBean> callback) {
      super("registerDevice", TMessageType.CALL, callback);
      this.newDevice = newDevice;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.newDevice != null) {
        protocol.writeFieldBegin("newDevice", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.write(protocol, this.newDevice);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected DeviceBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DeviceBean result = null;
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DeviceBean value = net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class ReleasePersonTokenCall extends MethodCall<Void> {
    private final Token token;

    ReleasePersonTokenCall(Token token, ServiceMethodCallback<Void> callback) {
      super("releasePersonToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class ReleaseRootTokenCall extends MethodCall<Void> {
    private final Token token;

    ReleaseRootTokenCall(Token token, ServiceMethodCallback<Void> callback) {
      super("releaseRootToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class ReleaseUserTokenCall extends MethodCall<Void> {
    private final Token token;

    ReleaseUserTokenCall(Token token, ServiceMethodCallback<Void> callback) {
      super("releaseUserToken", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class ReplaceFeatureCall extends MethodCall<Void> {
    private final Integer personId;

    private final String featureMd5;

    private final Boolean deleteOldFeatureImage;

    private final Token token;

    ReplaceFeatureCall(Integer personId, String featureMd5, Boolean deleteOldFeatureImage,
        Token token, ServiceMethodCallback<Void> callback) {
      super("replaceFeature", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.featureMd5 = featureMd5;
      if (deleteOldFeatureImage == null) throw new NullPointerException("deleteOldFeatureImage");
      this.deleteOldFeatureImage = deleteOldFeatureImage;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.featureMd5 != null) {
        protocol.writeFieldBegin("featureMd5", 2, TType.STRING);
        protocol.writeString(this.featureMd5);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("deleteOldFeatureImage", 3, TType.BOOL);
      protocol.writeBool(this.deleteOldFeatureImage);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class RootGroupOfDeviceCall extends MethodCall<Integer> {
    private final Integer deviceId;

    RootGroupOfDeviceCall(Integer deviceId, ServiceMethodCallback<Integer> callback) {
      super("rootGroupOfDevice", TMessageType.CALL, callback);
      if (deviceId == null) throw new NullPointerException("deviceId");
      this.deviceId = deviceId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceId", 1, TType.I32);
      protocol.writeI32(this.deviceId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class RootGroupOfDeviceGroupCall extends MethodCall<Integer> {
    private final Integer groupId;

    RootGroupOfDeviceGroupCall(Integer groupId, ServiceMethodCallback<Integer> callback) {
      super("rootGroupOfDeviceGroup", TMessageType.CALL, callback);
      if (groupId == null) throw new NullPointerException("groupId");
      this.groupId = groupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("groupId", 1, TType.I32);
      protocol.writeI32(this.groupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class RootGroupOfPersonCall extends MethodCall<Integer> {
    private final Integer personId;

    RootGroupOfPersonCall(Integer personId, ServiceMethodCallback<Integer> callback) {
      super("rootGroupOfPerson", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class RootGroupOfPersonGroupCall extends MethodCall<Integer> {
    private final Integer groupId;

    RootGroupOfPersonGroupCall(Integer groupId, ServiceMethodCallback<Integer> callback) {
      super("rootGroupOfPersonGroup", TMessageType.CALL, callback);
      if (groupId == null) throw new NullPointerException("groupId");
      this.groupId = groupId;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("groupId", 1, TType.I32);
      protocol.writeI32(this.groupId);
      protocol.writeFieldEnd();
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class RunCmdCall extends MethodCall<String> {
    private final List<Integer> target;

    private final Boolean group;

    private final String cmdpath;

    private final String jsonArgs;

    private final String ackChannel;

    private final Token token;

    RunCmdCall(List<Integer> target, Boolean group, String cmdpath, String jsonArgs,
        String ackChannel, Token token, ServiceMethodCallback<String> callback) {
      super("runCmd", TMessageType.CALL, callback);
      this.target = target;
      if (group == null) throw new NullPointerException("group");
      this.group = group;
      this.cmdpath = cmdpath;
      this.jsonArgs = jsonArgs;
      this.ackChannel = ackChannel;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.target != null) {
        protocol.writeFieldBegin("target", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.target.size());
        for (Integer item0 : this.target) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("group", 2, TType.BOOL);
      protocol.writeBool(this.group);
      protocol.writeFieldEnd();
      if (this.cmdpath != null) {
        protocol.writeFieldBegin("cmdpath", 3, TType.STRING);
        protocol.writeString(this.cmdpath);
        protocol.writeFieldEnd();
      }
      if (this.jsonArgs != null) {
        protocol.writeFieldBegin("jsonArgs", 4, TType.STRING);
        protocol.writeString(this.jsonArgs);
        protocol.writeFieldEnd();
      }
      if (this.ackChannel != null) {
        protocol.writeFieldBegin("ackChannel", 5, TType.STRING);
        protocol.writeString(this.ackChannel);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 6, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class RunTaskCall extends MethodCall<Integer> {
    private final String taskQueue;

    private final String cmdpath;

    private final String jsonArgs;

    private final String ackChannel;

    private final Token token;

    RunTaskCall(String taskQueue, String cmdpath, String jsonArgs, String ackChannel, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("runTask", TMessageType.CALL, callback);
      this.taskQueue = taskQueue;
      this.cmdpath = cmdpath;
      this.jsonArgs = jsonArgs;
      this.ackChannel = ackChannel;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.taskQueue != null) {
        protocol.writeFieldBegin("taskQueue", 1, TType.STRING);
        protocol.writeString(this.taskQueue);
        protocol.writeFieldEnd();
      }
      if (this.cmdpath != null) {
        protocol.writeFieldBegin("cmdpath", 2, TType.STRING);
        protocol.writeString(this.cmdpath);
        protocol.writeFieldEnd();
      }
      if (this.jsonArgs != null) {
        protocol.writeFieldBegin("jsonArgs", 3, TType.STRING);
        protocol.writeString(this.jsonArgs);
        protocol.writeFieldEnd();
      }
      if (this.ackChannel != null) {
        protocol.writeFieldBegin("ackChannel", 4, TType.STRING);
        protocol.writeString(this.ackChannel);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 5, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class RunTaskSyncCall extends MethodCall<String> {
    private final String taskQueue;

    private final String cmdpath;

    private final String jsonArgs;

    private final Integer timeoutSecs;

    private final Token token;

    RunTaskSyncCall(String taskQueue, String cmdpath, String jsonArgs, Integer timeoutSecs,
        Token token, ServiceMethodCallback<String> callback) {
      super("runTaskSync", TMessageType.CALL, callback);
      this.taskQueue = taskQueue;
      this.cmdpath = cmdpath;
      this.jsonArgs = jsonArgs;
      if (timeoutSecs == null) throw new NullPointerException("timeoutSecs");
      this.timeoutSecs = timeoutSecs;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.taskQueue != null) {
        protocol.writeFieldBegin("taskQueue", 1, TType.STRING);
        protocol.writeString(this.taskQueue);
        protocol.writeFieldEnd();
      }
      if (this.cmdpath != null) {
        protocol.writeFieldBegin("cmdpath", 2, TType.STRING);
        protocol.writeString(this.cmdpath);
        protocol.writeFieldEnd();
      }
      if (this.jsonArgs != null) {
        protocol.writeFieldBegin("jsonArgs", 3, TType.STRING);
        protocol.writeString(this.jsonArgs);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("timeoutSecs", 4, TType.I32);
      protocol.writeI32(this.timeoutSecs);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 5, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SaveDeviceCall extends MethodCall<DeviceBean> {
    private final DeviceBean deviceBean;

    private final Token token;

    SaveDeviceCall(DeviceBean deviceBean, Token token, ServiceMethodCallback<DeviceBean> callback) {
      super("saveDevice", TMessageType.CALL, callback);
      this.deviceBean = deviceBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.deviceBean != null) {
        protocol.writeFieldBegin("deviceBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.write(protocol, this.deviceBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected DeviceBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DeviceBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DeviceBean value = net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SaveDeviceGroupCall extends MethodCall<DeviceGroupBean> {
    private final DeviceGroupBean deviceGroupBean;

    private final Token token;

    SaveDeviceGroupCall(DeviceGroupBean deviceGroupBean, Token token,
        ServiceMethodCallback<DeviceGroupBean> callback) {
      super("saveDeviceGroup", TMessageType.CALL, callback);
      this.deviceGroupBean = deviceGroupBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.deviceGroupBean != null) {
        protocol.writeFieldBegin("deviceGroupBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.DeviceGroupBean.ADAPTER.write(protocol, this.deviceGroupBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected DeviceGroupBean receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      DeviceGroupBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DeviceGroupBean value = net.gdface.facelog.client.thrift.DeviceGroupBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePermitCall extends MethodCall<PermitBean> {
    private final PermitBean permitBean;

    private final Token token;

    SavePermitCall(PermitBean permitBean, Token token, ServiceMethodCallback<PermitBean> callback) {
      super("savePermit", TMessageType.CALL, callback);
      this.permitBean = permitBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.permitBean != null) {
        protocol.writeFieldBegin("permitBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PermitBean.ADAPTER.write(protocol, this.permitBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PermitBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PermitBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PermitBean value = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePermitWithColumnCall extends MethodCall<PermitBean> {
    private final Integer deviceGroupId;

    private final Integer personGroupId;

    private final String column;

    private final String value;

    private final Token token;

    SavePermitWithColumnCall(Integer deviceGroupId, Integer personGroupId, String column,
        String value, Token token, ServiceMethodCallback<PermitBean> callback) {
      super("savePermitWithColumn", TMessageType.CALL, callback);
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
      this.column = column;
      this.value = value;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("deviceGroupId", 1, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("personGroupId", 2, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      if (this.column != null) {
        protocol.writeFieldBegin("column", 3, TType.STRING);
        protocol.writeString(this.column);
        protocol.writeFieldEnd();
      }
      if (this.value != null) {
        protocol.writeFieldBegin("value", 4, TType.STRING);
        protocol.writeString(this.value);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 5, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PermitBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PermitBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PermitBean value = net.gdface.facelog.client.thrift.PermitBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonCall extends MethodCall<PersonBean> {
    private final PersonBean personBean;

    private final Token token;

    SavePersonCall(PersonBean personBean, Token token, ServiceMethodCallback<PersonBean> callback) {
      super("savePerson", TMessageType.CALL, callback);
      this.personBean = personBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personBean != null) {
        protocol.writeFieldBegin("personBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, this.personBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonFullCall extends MethodCall<PersonBean> {
    private final PersonBean personBean;

    private final ByteString idPhoto;

    private final ByteString feature;

    private final String featureVersion;

    private final ByteString featureImage;

    private final FaceBean faceBean;

    private final Token token;

    SavePersonFullCall(PersonBean personBean, ByteString idPhoto, ByteString feature,
        String featureVersion, ByteString featureImage, FaceBean faceBean, Token token,
        ServiceMethodCallback<PersonBean> callback) {
      super("savePersonFull", TMessageType.CALL, callback);
      this.personBean = personBean;
      this.idPhoto = idPhoto;
      this.feature = feature;
      this.featureVersion = featureVersion;
      this.featureImage = featureImage;
      this.faceBean = faceBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personBean != null) {
        protocol.writeFieldBegin("personBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, this.personBean);
        protocol.writeFieldEnd();
      }
      if (this.idPhoto != null) {
        protocol.writeFieldBegin("idPhoto", 2, TType.STRING);
        protocol.writeBinary(this.idPhoto);
        protocol.writeFieldEnd();
      }
      if (this.feature != null) {
        protocol.writeFieldBegin("feature", 3, TType.STRING);
        protocol.writeBinary(this.feature);
        protocol.writeFieldEnd();
      }
      if (this.featureVersion != null) {
        protocol.writeFieldBegin("featureVersion", 4, TType.STRING);
        protocol.writeString(this.featureVersion);
        protocol.writeFieldEnd();
      }
      if (this.featureImage != null) {
        protocol.writeFieldBegin("featureImage", 5, TType.STRING);
        protocol.writeBinary(this.featureImage);
        protocol.writeFieldEnd();
      }
      if (this.faceBean != null) {
        protocol.writeFieldBegin("faceBean", 6, TType.STRUCT);
        net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, this.faceBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 7, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonGroupCall extends MethodCall<PersonGroupBean> {
    private final PersonGroupBean personGroupBean;

    private final Token token;

    SavePersonGroupCall(PersonGroupBean personGroupBean, Token token,
        ServiceMethodCallback<PersonGroupBean> callback) {
      super("savePersonGroup", TMessageType.CALL, callback);
      this.personGroupBean = personGroupBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personGroupBean != null) {
        protocol.writeFieldBegin("personGroupBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonGroupBean.ADAPTER.write(protocol, this.personGroupBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonGroupBean receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      PersonGroupBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonGroupBean value = net.gdface.facelog.client.thrift.PersonGroupBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonWithPhotoCall extends MethodCall<PersonBean> {
    private final PersonBean personBean;

    private final ByteString idPhoto;

    private final Token token;

    SavePersonWithPhotoCall(PersonBean personBean, ByteString idPhoto, Token token,
        ServiceMethodCallback<PersonBean> callback) {
      super("savePersonWithPhoto", TMessageType.CALL, callback);
      this.personBean = personBean;
      this.idPhoto = idPhoto;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personBean != null) {
        protocol.writeFieldBegin("personBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, this.personBean);
        protocol.writeFieldEnd();
      }
      if (this.idPhoto != null) {
        protocol.writeFieldBegin("idPhoto", 2, TType.STRING);
        protocol.writeBinary(this.idPhoto);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonWithPhotoAndFeatureCall extends MethodCall<PersonBean> {
    private final PersonBean personBean;

    private final ByteString idPhoto;

    private final FeatureBean featureBean;

    private final Token token;

    SavePersonWithPhotoAndFeatureCall(PersonBean personBean, ByteString idPhoto,
        FeatureBean featureBean, Token token, ServiceMethodCallback<PersonBean> callback) {
      super("savePersonWithPhotoAndFeature", TMessageType.CALL, callback);
      this.personBean = personBean;
      this.idPhoto = idPhoto;
      this.featureBean = featureBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personBean != null) {
        protocol.writeFieldBegin("personBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, this.personBean);
        protocol.writeFieldEnd();
      }
      if (this.idPhoto != null) {
        protocol.writeFieldBegin("idPhoto", 2, TType.STRING);
        protocol.writeBinary(this.idPhoto);
        protocol.writeFieldEnd();
      }
      if (this.featureBean != null) {
        protocol.writeFieldBegin("featureBean", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.FeatureBean.ADAPTER.write(protocol, this.featureBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonWithPhotoAndFeatureMultiFacesCall extends MethodCall<PersonBean> {
    private final PersonBean personBean;

    private final ByteString idPhoto;

    private final ByteString feature;

    private final String featureVersion;

    private final List<FaceBean> faceBeans;

    private final Token token;

    SavePersonWithPhotoAndFeatureMultiFacesCall(PersonBean personBean, ByteString idPhoto,
        ByteString feature, String featureVersion, List<FaceBean> faceBeans, Token token,
        ServiceMethodCallback<PersonBean> callback) {
      super("savePersonWithPhotoAndFeatureMultiFaces", TMessageType.CALL, callback);
      this.personBean = personBean;
      this.idPhoto = idPhoto;
      this.feature = feature;
      this.featureVersion = featureVersion;
      this.faceBeans = faceBeans;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personBean != null) {
        protocol.writeFieldBegin("personBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, this.personBean);
        protocol.writeFieldEnd();
      }
      if (this.idPhoto != null) {
        protocol.writeFieldBegin("idPhoto", 2, TType.STRING);
        protocol.writeBinary(this.idPhoto);
        protocol.writeFieldEnd();
      }
      if (this.feature != null) {
        protocol.writeFieldBegin("feature", 3, TType.STRING);
        protocol.writeBinary(this.feature);
        protocol.writeFieldEnd();
      }
      if (this.featureVersion != null) {
        protocol.writeFieldBegin("featureVersion", 4, TType.STRING);
        protocol.writeString(this.featureVersion);
        protocol.writeFieldEnd();
      }
      if (this.faceBeans != null) {
        protocol.writeFieldBegin("faceBeans", 5, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.faceBeans.size());
        for (FaceBean item0 : this.faceBeans) {
          net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 6, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonWithPhotoAndFeatureMultiImageCall extends MethodCall<PersonBean> {
    private final PersonBean personBean;

    private final ByteString idPhoto;

    private final ByteString feature;

    private final String featureVersion;

    private final List<ByteString> photos;

    private final List<FaceBean> faces;

    private final Token token;

    SavePersonWithPhotoAndFeatureMultiImageCall(PersonBean personBean, ByteString idPhoto,
        ByteString feature, String featureVersion, List<ByteString> photos, List<FaceBean> faces,
        Token token, ServiceMethodCallback<PersonBean> callback) {
      super("savePersonWithPhotoAndFeatureMultiImage", TMessageType.CALL, callback);
      this.personBean = personBean;
      this.idPhoto = idPhoto;
      this.feature = feature;
      this.featureVersion = featureVersion;
      this.photos = photos;
      this.faces = faces;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personBean != null) {
        protocol.writeFieldBegin("personBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, this.personBean);
        protocol.writeFieldEnd();
      }
      if (this.idPhoto != null) {
        protocol.writeFieldBegin("idPhoto", 2, TType.STRING);
        protocol.writeBinary(this.idPhoto);
        protocol.writeFieldEnd();
      }
      if (this.feature != null) {
        protocol.writeFieldBegin("feature", 3, TType.STRING);
        protocol.writeBinary(this.feature);
        protocol.writeFieldEnd();
      }
      if (this.featureVersion != null) {
        protocol.writeFieldBegin("featureVersion", 4, TType.STRING);
        protocol.writeString(this.featureVersion);
        protocol.writeFieldEnd();
      }
      if (this.photos != null) {
        protocol.writeFieldBegin("photos", 5, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.photos.size());
        for (ByteString item0 : this.photos) {
          protocol.writeBinary(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.faces != null) {
        protocol.writeFieldBegin("faces", 6, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.faces.size());
        for (FaceBean item0 : this.faces) {
          net.gdface.facelog.client.thrift.FaceBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 7, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonWithPhotoAndFeatureSavedCall extends MethodCall<PersonBean> {
    private final PersonBean personBean;

    private final String idPhotoMd5;

    private final String featureMd5;

    private final Token token;

    SavePersonWithPhotoAndFeatureSavedCall(PersonBean personBean, String idPhotoMd5,
        String featureMd5, Token token, ServiceMethodCallback<PersonBean> callback) {
      super("savePersonWithPhotoAndFeatureSaved", TMessageType.CALL, callback);
      this.personBean = personBean;
      this.idPhotoMd5 = idPhotoMd5;
      this.featureMd5 = featureMd5;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personBean != null) {
        protocol.writeFieldBegin("personBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, this.personBean);
        protocol.writeFieldEnd();
      }
      if (this.idPhotoMd5 != null) {
        protocol.writeFieldBegin("idPhotoMd5", 2, TType.STRING);
        protocol.writeString(this.idPhotoMd5);
        protocol.writeFieldEnd();
      }
      if (this.featureMd5 != null) {
        protocol.writeFieldBegin("featureMd5", 3, TType.STRING);
        protocol.writeString(this.featureMd5);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 4, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected PersonBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      PersonBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.PersonBean value = net.gdface.facelog.client.thrift.PersonBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SavePersonsCall extends MethodCall<Void> {
    private final List<PersonBean> persons;

    private final Token token;

    SavePersonsCall(List<PersonBean> persons, Token token, ServiceMethodCallback<Void> callback) {
      super("savePersons", TMessageType.CALL, callback);
      this.persons = persons;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.persons != null) {
        protocol.writeFieldBegin("persons", 1, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.persons.size());
        for (PersonBean item0 : this.persons) {
          net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class SavePersonsWithPhotoCall extends MethodCall<Integer> {
    private final List<ByteString> photos;

    private final List<PersonBean> persons;

    private final Token token;

    SavePersonsWithPhotoCall(List<ByteString> photos, List<PersonBean> persons, Token token,
        ServiceMethodCallback<Integer> callback) {
      super("savePersonsWithPhoto", TMessageType.CALL, callback);
      this.photos = photos;
      this.persons = persons;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.photos != null) {
        protocol.writeFieldBegin("photos", 1, TType.LIST);
        protocol.writeListBegin(TType.STRING, this.photos.size());
        for (ByteString item0 : this.photos) {
          protocol.writeBinary(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.persons != null) {
        protocol.writeFieldBegin("persons", 2, TType.LIST);
        protocol.writeListBegin(TType.STRUCT, this.persons.size());
        for (PersonBean item0 : this.persons) {
          net.gdface.facelog.client.thrift.PersonBean.ADAPTER.write(protocol, item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Integer receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      Integer result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.I32) {
              int value = protocol.readI32();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SaveServiceConfigCall extends MethodCall<Void> {
    private final Token token;

    SaveServiceConfigCall(Token token, ServiceMethodCallback<Void> callback) {
      super("saveServiceConfig", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class SdkTaskQueueOfCall extends MethodCall<String> {
    private final String task;

    private final String sdkVersion;

    private final Token token;

    SdkTaskQueueOfCall(String task, String sdkVersion, Token token,
        ServiceMethodCallback<String> callback) {
      super("sdkTaskQueueOf", TMessageType.CALL, callback);
      this.task = task;
      this.sdkVersion = sdkVersion;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.task != null) {
        protocol.writeFieldBegin("task", 1, TType.STRING);
        protocol.writeString(this.task);
        protocol.writeFieldEnd();
      }
      if (this.sdkVersion != null) {
        protocol.writeFieldBegin("sdkVersion", 2, TType.STRING);
        protocol.writeString(this.sdkVersion);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class SetPersonExpiryDateCall extends MethodCall<Void> {
    private final Integer personId;

    private final Long expiryDate;

    private final Token token;

    SetPersonExpiryDateCall(Integer personId, Long expiryDate, Token token,
        ServiceMethodCallback<Void> callback) {
      super("setPersonExpiryDate", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      if (expiryDate == null) throw new NullPointerException("expiryDate");
      this.expiryDate = expiryDate;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("expiryDate", 2, TType.I64);
      protocol.writeI64(this.expiryDate);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class SetPersonExpiryDateListCall extends MethodCall<Void> {
    private final List<Integer> personIdList;

    private final Long expiryDate;

    private final Token token;

    SetPersonExpiryDateListCall(List<Integer> personIdList, Long expiryDate, Token token,
        ServiceMethodCallback<Void> callback) {
      super("setPersonExpiryDateList", TMessageType.CALL, callback);
      this.personIdList = personIdList;
      if (expiryDate == null) throw new NullPointerException("expiryDate");
      this.expiryDate = expiryDate;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.personIdList != null) {
        protocol.writeFieldBegin("personIdList", 1, TType.LIST);
        protocol.writeListBegin(TType.I32, this.personIdList.size());
        for (Integer item0 : this.personIdList) {
          protocol.writeI32(item0);
        }
        protocol.writeListEnd();
        protocol.writeFieldEnd();
      }
      protocol.writeFieldBegin("expiryDate", 2, TType.I64);
      protocol.writeI64(this.expiryDate);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class SetPersonExpiryDateTimeStrCall extends MethodCall<Void> {
    private final Integer personId;

    private final String expiryDate;

    private final Token token;

    SetPersonExpiryDateTimeStrCall(Integer personId, String expiryDate, Token token,
        ServiceMethodCallback<Void> callback) {
      super("setPersonExpiryDateTimeStr", TMessageType.CALL, callback);
      if (personId == null) throw new NullPointerException("personId");
      this.personId = personId;
      this.expiryDate = expiryDate;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personId", 1, TType.I32);
      protocol.writeI32(this.personId);
      protocol.writeFieldEnd();
      if (this.expiryDate != null) {
        protocol.writeFieldBegin("expiryDate", 2, TType.STRING);
        protocol.writeString(this.expiryDate);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class SetPropertiesCall extends MethodCall<Void> {
    private final Map<String, String> config;

    private final Token token;

    SetPropertiesCall(Map<String, String> config, Token token,
        ServiceMethodCallback<Void> callback) {
      super("setProperties", TMessageType.CALL, callback);
      this.config = config;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.config != null) {
        protocol.writeFieldBegin("config", 1, TType.MAP);
        protocol.writeMapBegin(TType.STRING, TType.STRING, this.config.size());
        for (Map.Entry<String, String> entry0 : this.config.entrySet()) {
          String key0 = entry0.getKey();
          String value0 = entry0.getValue();
          protocol.writeString(key0);
          protocol.writeString(value0);
        }
        protocol.writeMapEnd();
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class SetPropertyCall extends MethodCall<Void> {
    private final String key;

    private final String value;

    private final Token token;

    SetPropertyCall(String key, String value, Token token, ServiceMethodCallback<Void> callback) {
      super("setProperty", TMessageType.CALL, callback);
      this.key = key;
      this.value = value;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.key != null) {
        protocol.writeFieldBegin("key", 1, TType.STRING);
        protocol.writeString(this.key);
        protocol.writeFieldEnd();
      }
      if (this.value != null) {
        protocol.writeFieldBegin("value", 2, TType.STRING);
        protocol.writeString(this.value);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class TaskQueueOfCall extends MethodCall<String> {
    private final String task;

    private final Token token;

    TaskQueueOfCall(String task, Token token, ServiceMethodCallback<String> callback) {
      super("taskQueueOf", TMessageType.CALL, callback);
      this.task = task;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.task != null) {
        protocol.writeFieldBegin("task", 1, TType.STRING);
        protocol.writeString(this.task);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class UnbindBorderCall extends MethodCall<Void> {
    private final Integer personGroupId;

    private final Integer deviceGroupId;

    private final Token token;

    UnbindBorderCall(Integer personGroupId, Integer deviceGroupId, Token token,
        ServiceMethodCallback<Void> callback) {
      super("unbindBorder", TMessageType.CALL, callback);
      if (personGroupId == null) throw new NullPointerException("personGroupId");
      this.personGroupId = personGroupId;
      if (deviceGroupId == null) throw new NullPointerException("deviceGroupId");
      this.deviceGroupId = deviceGroupId;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldBegin("personGroupId", 1, TType.I32);
      protocol.writeI32(this.personGroupId);
      protocol.writeFieldEnd();
      protocol.writeFieldBegin("deviceGroupId", 2, TType.I32);
      protocol.writeI32(this.deviceGroupId);
      protocol.writeFieldEnd();
      if (this.token != null) {
        protocol.writeFieldBegin("token", 3, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else {
        return null;
      }
    }
  }

  private static final class UnregisterDeviceCall extends MethodCall<Void> {
    private final Token token;

    UnregisterDeviceCall(Token token, ServiceMethodCallback<Void> callback) {
      super("unregisterDevice", TMessageType.CALL, callback);
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.token != null) {
        protocol.writeFieldBegin("token", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Void receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      ServiceSecurityException ex1 = null;
      ServiceRuntimeException ex2 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceSecurityException value = net.gdface.facelog.client.thrift.ServiceSecurityException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 2: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex2 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (ex1 != null) {
        throw ex1;
      } else if (ex2 != null) {
        throw ex2;
      } else {
        return null;
      }
    }
  }

  private static final class UpdateDeviceCall extends MethodCall<DeviceBean> {
    private final DeviceBean deviceBean;

    private final Token token;

    UpdateDeviceCall(DeviceBean deviceBean, Token token,
        ServiceMethodCallback<DeviceBean> callback) {
      super("updateDevice", TMessageType.CALL, callback);
      this.deviceBean = deviceBean;
      this.token = token;
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      if (this.deviceBean != null) {
        protocol.writeFieldBegin("deviceBean", 1, TType.STRUCT);
        net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.write(protocol, this.deviceBean);
        protocol.writeFieldEnd();
      }
      if (this.token != null) {
        protocol.writeFieldBegin("token", 2, TType.STRUCT);
        net.gdface.facelog.client.thrift.Token.ADAPTER.write(protocol, this.token);
        protocol.writeFieldEnd();
      }
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected DeviceBean receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      DeviceBean result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.DeviceBean value = net.gdface.facelog.client.thrift.DeviceBean.ADAPTER.read(protocol);
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class VersionCall extends MethodCall<String> {
    VersionCall(ServiceMethodCallback<String> callback) {
      super("version", TMessageType.CALL, callback);
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected String receive(Protocol protocol, MessageMetadata metadata) throws Exception {
      String result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.STRING) {
              String value = protocol.readString();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }

  private static final class VersionInfoCall extends MethodCall<Map<String, String>> {
    VersionInfoCall(ServiceMethodCallback<Map<String, String>> callback) {
      super("versionInfo", TMessageType.CALL, callback);
    }

    @Override
    protected void send(Protocol protocol) throws IOException {
      protocol.writeStructBegin("args");
      protocol.writeFieldStop();
      protocol.writeStructEnd();
    }

    @Override
    protected Map<String, String> receive(Protocol protocol, MessageMetadata metadata) throws
        Exception {
      Map<String, String> result = null;
      ServiceRuntimeException ex1 = null;
      protocol.readStructBegin();
      while (true) {
        FieldMetadata field = protocol.readFieldBegin();
        if (field.typeId == TType.STOP) {
          break;
        }
        switch (field.fieldId) {
          case 0: {
            if (field.typeId == TType.MAP) {
              MapMetadata mapMetadata0 = protocol.readMapBegin();
              Map<String, String> value = new HashMap<String, String>(mapMetadata0.size);
              for (int i0 = 0; i0 < mapMetadata0.size; ++i0) {
                String key0 = protocol.readString();
                String value0 = protocol.readString();
                value.put(key0, value0);
              }
              protocol.readMapEnd();
              result = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          case 1: {
            if (field.typeId == TType.STRUCT) {
              net.gdface.facelog.client.thrift.ServiceRuntimeException value = net.gdface.facelog.client.thrift.ServiceRuntimeException.ADAPTER.read(protocol);
              ex1 = value;
            } else {
              ProtocolUtil.skip(protocol, field.typeId);
            }
          }
          break;
          default: ProtocolUtil.skip(protocol, field.typeId); break;
        }
        protocol.readFieldEnd();
      }
      protocol.readStructEnd();
      if (result != null) {
        return result;
      } else if (ex1 != null) {
        throw ex1;
      } else {
        throw new ThriftException(ThriftException.Kind.MISSING_RESULT, "Missing result");
      }
    }
  }
}