"Fossies" - the Fresh Open Source Software Archive

Member "irods-4.2.8/lib/api/include/apiTable.hpp" (14 May 2020, 61546 Bytes) of package /linux/misc/irods-4.2.8.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "apiTable.hpp" see the Fossies "Dox" file reference documentation.

    1 #ifndef API_TABLE_HPP
    2 #define API_TABLE_HPP
    3 
    4 #include <functional>
    5 #include <boost/any.hpp>
    6 #include "apiHandler.hpp"
    7 #include "apiHeaderAll.h"
    8 #include "apiNumber.h"
    9 #include "client_hints.h"
   10 #include "dataObjInpOut.h"
   11 #include "ies_client_hints.h"
   12 #include "irods_api_calling_functions.hpp"
   13 #include "rods.h"
   14 #include "rodsUser.h"
   15 #include "server_report.h"
   16 #include "zone_report.h"
   17 
   18 
   19 
   20 #if defined(CREATE_API_TABLE_FOR_SERVER) && !defined(CREATE_API_TABLE_FOR_CLIENT)
   21 #include "rsAuthCheck.hpp"
   22 #include "rsAuthPluginRequest.hpp"
   23 #include "rsAuthRequest.hpp"
   24 #include "rsAuthResponse.hpp"
   25 #include "rsAuthenticate.hpp"
   26 #include "rsBulkDataObjPut.hpp"
   27 #include "rsBulkDataObjReg.hpp"
   28 #include "rsChkNVPathPerm.hpp"
   29 #include "rsChkObjPermAndStat.hpp"
   30 #include "rsClientHints.hpp"
   31 #include "rsCloseCollection.hpp"
   32 #include "rsCollCreate.hpp"
   33 #include "rsCollRepl.hpp"
   34 #include "rsDataCopy.hpp"
   35 #include "rsDataGet.hpp"
   36 #include "rsDataObjChksum.hpp"
   37 #include "rsDataObjClose.hpp"
   38 #include "rsDataObjCopy.hpp"
   39 #include "rsDataObjCreate.hpp"
   40 #include "rsDataObjCreateAndStat.hpp"
   41 #include "rsDataObjGet.hpp"
   42 #include "rsDataObjLock.hpp"
   43 #include "rsDataObjLseek.hpp"
   44 #include "rsDataObjOpen.hpp"
   45 #include "rsDataObjOpenAndStat.hpp"
   46 #include "rsDataObjPhymv.hpp"
   47 #include "rsDataObjPut.hpp"
   48 #include "rsDataObjRead.hpp"
   49 #include "rsDataObjRename.hpp"
   50 #include "rsDataObjRepl.hpp"
   51 #include "rsDataObjRsync.hpp"
   52 #include "rsDataObjTrim.hpp"
   53 #include "rsDataObjTruncate.hpp"
   54 #include "rsDataObjUnlink.hpp"
   55 #include "rsDataObjWrite.hpp"
   56 #include "rsDataPut.hpp"
   57 #include "rsEndTransaction.hpp"
   58 #include "rsExecCmd.hpp"
   59 #include "rsExecMyRule.hpp"
   60 #include "rsExecRuleExpression.hpp"
   61 #include "rsFileChksum.hpp"
   62 #include "rsFileChmod.hpp"
   63 #include "rsFileClose.hpp"
   64 #include "rsFileClosedir.hpp"
   65 #include "rsFileCreate.hpp"
   66 #include "rsFileGet.hpp"
   67 #include "rsFileGetFsFreeSpace.hpp"
   68 #include "rsFileLseek.hpp"
   69 #include "rsFileMkdir.hpp"
   70 #include "rsFileOpen.hpp"
   71 #include "rsFileOpendir.hpp"
   72 #include "rsFilePut.hpp"
   73 #include "rsFileRead.hpp"
   74 #include "rsFileReaddir.hpp"
   75 #include "rsFileRename.hpp"
   76 #include "rsFileRmdir.hpp"
   77 #include "rsFileStageToCache.hpp"
   78 #include "rsFileStat.hpp"
   79 #include "rsFileSyncToArch.hpp"
   80 #include "rsFileTruncate.hpp"
   81 #include "rsFileUnlink.hpp"
   82 #include "rsFileWrite.hpp"
   83 #include "rsGenQuery.hpp"
   84 #include "rsGeneralAdmin.hpp"
   85 #include "rsGeneralRowInsert.hpp"
   86 #include "rsGeneralRowPurge.hpp"
   87 #include "rsGeneralUpdate.hpp"
   88 #include "rsGetHierFromLeafId.hpp"
   89 #include "rsGetHierarchyForResc.hpp"
   90 #include "rsGetHostForGet.hpp"
   91 #include "rsGetHostForPut.hpp"
   92 #include "rsGetLimitedPassword.hpp"
   93 #include "rsGetMiscSvrInfo.hpp"
   94 #include "rsGetRemoteZoneResc.hpp"
   95 #include "rsGetRescQuota.hpp"
   96 #include "rsGetTempPassword.hpp"
   97 #include "rsGetTempPasswordForOther.hpp"
   98 #include "rsGetXmsgTicket.hpp"
   99 #include "rsIESClientHints.hpp"
  100 #include "rsL3FileGetSingleBuf.hpp"
  101 #include "rsL3FilePutSingleBuf.hpp"
  102 #include "rsModAVUMetadata.hpp"
  103 #include "rsModAccessControl.hpp"
  104 #include "rsModColl.hpp"
  105 #include "rsModDataObjMeta.hpp"
  106 #include "rsObjStat.hpp"
  107 #include "rsOpenCollection.hpp"
  108 #include "rsOprComplete.hpp"
  109 #include "rsPamAuthRequest.hpp"
  110 #include "rsPhyBundleColl.hpp"
  111 #include "rsPhyPathReg.hpp"
  112 #include "rsProcStat.hpp"
  113 #include "rsQuerySpecColl.hpp"
  114 #include "rsRcvXmsg.hpp"
  115 #include "rsReadCollection.hpp"
  116 #include "rsRegColl.hpp"
  117 #include "rsRegDataObj.hpp"
  118 #include "rsRegReplica.hpp"
  119 #include "rsRmColl.hpp"
  120 #include "rsRuleExecDel.hpp"
  121 #include "rsRuleExecMod.hpp"
  122 #include "rsRuleExecSubmit.hpp"
  123 #include "rsSendXmsg.hpp"
  124 #include "rsServerReport.hpp"
  125 #include "rsSetRoundRobinContext.hpp"
  126 #include "rsSimpleQuery.hpp"
  127 #include "rsSpecificQuery.hpp"
  128 #include "rsSslEnd.hpp"
  129 #include "rsSslStart.hpp"
  130 #include "rsStreamClose.hpp"
  131 #include "rsStreamRead.hpp"
  132 #include "rsStructFileBundle.hpp"
  133 #include "rsStructFileExtAndReg.hpp"
  134 #include "rsStructFileExtract.hpp"
  135 #include "rsStructFileSync.hpp"
  136 #include "rsSubStructFileClose.hpp"
  137 #include "rsSubStructFileClosedir.hpp"
  138 #include "rsSubStructFileCreate.hpp"
  139 #include "rsSubStructFileGet.hpp"
  140 #include "rsSubStructFileLseek.hpp"
  141 #include "rsSubStructFileMkdir.hpp"
  142 #include "rsSubStructFileOpen.hpp"
  143 #include "rsSubStructFileOpendir.hpp"
  144 #include "rsSubStructFilePut.hpp"
  145 #include "rsSubStructFileRead.hpp"
  146 #include "rsSubStructFileReaddir.hpp"
  147 #include "rsSubStructFileRename.hpp"
  148 #include "rsSubStructFileRmdir.hpp"
  149 #include "rsSubStructFileStat.hpp"
  150 #include "rsSubStructFileTruncate.hpp"
  151 #include "rsSubStructFileUnlink.hpp"
  152 #include "rsSubStructFileWrite.hpp"
  153 #include "rsSyncMountedColl.hpp"
  154 #include "rsTicketAdmin.hpp"
  155 #include "rsUnbunAndRegPhyBunfile.hpp"
  156 #include "rsUnregDataObj.hpp"
  157 #include "rsUserAdmin.hpp"
  158 #include "rsZoneReport.hpp"
  159 #define NULLPTR_FOR_CLIENT_TABLE(x) x
  160 #elif !defined(CREATE_API_TABLE_FOR_SERVER) && defined(CREATE_API_TABLE_FOR_CLIENT)
  161 #define NULLPTR_FOR_CLIENT_TABLE(x) nullptr
  162 #else
  163 #error "exactly one of {CREATE_API_TABLE_FOR_SERVER, CREATE_API_TABLE_FOR_CLIENT} must be defined"
  164 #endif
  165 
  166 
  167 
  168 #define RS_AUTHENTICATE NULLPTR_FOR_CLIENT_TABLE(rsAuthenticate)
  169 #define RS_AUTH_CHECK NULLPTR_FOR_CLIENT_TABLE(rsAuthCheck)
  170 #define RS_AUTH_PLUG_REQ NULLPTR_FOR_CLIENT_TABLE(rsAuthPluginRequest)
  171 #define RS_AUTH_REQUEST NULLPTR_FOR_CLIENT_TABLE(rsAuthRequest)
  172 #define RS_AUTH_RESPONSE NULLPTR_FOR_CLIENT_TABLE(rsAuthResponse)
  173 #define RS_BULK_DATA_OBJ_PUT NULLPTR_FOR_CLIENT_TABLE(rsBulkDataObjPut)
  174 #define RS_BULK_DATA_OBJ_REG NULLPTR_FOR_CLIENT_TABLE(rsBulkDataObjReg)
  175 #define RS_CHK_NV_PATH_PERM NULLPTR_FOR_CLIENT_TABLE(rsChkNVPathPerm)
  176 #define RS_CHK_OBJ_PERM_AND_STAT NULLPTR_FOR_CLIENT_TABLE(rsChkObjPermAndStat)
  177 #define RS_CLIENT_HINTS NULLPTR_FOR_CLIENT_TABLE(rsClientHints)
  178 #define RS_CLOSE_COLLECTION NULLPTR_FOR_CLIENT_TABLE(rsCloseCollection)
  179 #define RS_COLL_CREATE NULLPTR_FOR_CLIENT_TABLE(rsCollCreate)
  180 #define RS_COLL_REPL NULLPTR_FOR_CLIENT_TABLE(rsCollRepl)
  181 #define RS_DATA_COPY NULLPTR_FOR_CLIENT_TABLE(rsDataCopy)
  182 #define RS_DATA_GET NULLPTR_FOR_CLIENT_TABLE(rsDataGet)
  183 #define RS_DATA_OBJ_CHKSUM NULLPTR_FOR_CLIENT_TABLE(rsDataObjChksum)
  184 #define RS_DATA_OBJ_CLOSE NULLPTR_FOR_CLIENT_TABLE(rsDataObjClose)
  185 #define RS_DATA_OBJ_COPY NULLPTR_FOR_CLIENT_TABLE(rsDataObjCopy)
  186 #define RS_DATA_OBJ_CREATE NULLPTR_FOR_CLIENT_TABLE(rsDataObjCreate)
  187 #define RS_DATA_OBJ_CREATE_AND_STAT NULLPTR_FOR_CLIENT_TABLE(rsDataObjCreateAndStat)
  188 #define RS_DATA_OBJ_GET NULLPTR_FOR_CLIENT_TABLE(rsDataObjGet)
  189 #define RS_DATA_OBJ_LOCK NULLPTR_FOR_CLIENT_TABLE(rsDataObjLock)
  190 #define RS_DATA_OBJ_LSEEK NULLPTR_FOR_CLIENT_TABLE(rsDataObjLseek)
  191 #define RS_DATA_OBJ_OPEN NULLPTR_FOR_CLIENT_TABLE(rsDataObjOpen)
  192 #define RS_DATA_OBJ_OPEN_AND_STAT NULLPTR_FOR_CLIENT_TABLE(rsDataObjOpenAndStat)
  193 #define RS_DATA_OBJ_PHYMV NULLPTR_FOR_CLIENT_TABLE(rsDataObjPhymv)
  194 #define RS_DATA_OBJ_PUT NULLPTR_FOR_CLIENT_TABLE(rsDataObjPut)
  195 #define RS_DATA_OBJ_READ NULLPTR_FOR_CLIENT_TABLE(rsDataObjRead)
  196 #define RS_DATA_OBJ_RENAME NULLPTR_FOR_CLIENT_TABLE(rsDataObjRename)
  197 #define RS_DATA_OBJ_REPL NULLPTR_FOR_CLIENT_TABLE(rsDataObjRepl)
  198 #define RS_DATA_OBJ_RSYNC NULLPTR_FOR_CLIENT_TABLE(rsDataObjRsync)
  199 #define RS_DATA_OBJ_TRIM NULLPTR_FOR_CLIENT_TABLE(rsDataObjTrim)
  200 #define RS_DATA_OBJ_TRUNCATE NULLPTR_FOR_CLIENT_TABLE(rsDataObjTruncate)
  201 #define RS_DATA_OBJ_UNLINK NULLPTR_FOR_CLIENT_TABLE(rsDataObjUnlink)
  202 #define RS_DATA_OBJ_UNLOCK NULLPTR_FOR_CLIENT_TABLE(rsDataObjUnlock)
  203 #define RS_DATA_OBJ_WRITE NULLPTR_FOR_CLIENT_TABLE(rsDataObjWrite)
  204 #define RS_DATA_PUT NULLPTR_FOR_CLIENT_TABLE(rsDataPut)
  205 #define RS_END_TRANSACTION NULLPTR_FOR_CLIENT_TABLE(rsEndTransaction)
  206 #define RS_EXEC_CMD NULLPTR_FOR_CLIENT_TABLE(rsExecCmd)
  207 #define RS_EXEC_MY_RULE NULLPTR_FOR_CLIENT_TABLE(rsExecMyRule)
  208 #define RS_EXEC_RULE_EXPRESSION NULLPTR_FOR_CLIENT_TABLE(rsExecRuleExpression)
  209 #define RS_FILE_CHKSUM NULLPTR_FOR_CLIENT_TABLE(rsFileChksum)
  210 #define RS_FILE_CHMOD NULLPTR_FOR_CLIENT_TABLE(rsFileChmod)
  211 #define RS_FILE_CLOSE NULLPTR_FOR_CLIENT_TABLE(rsFileClose)
  212 #define RS_FILE_CLOSEDIR NULLPTR_FOR_CLIENT_TABLE(rsFileClosedir)
  213 #define RS_FILE_CREATE NULLPTR_FOR_CLIENT_TABLE(rsFileCreate)
  214 #define RS_FILE_GET NULLPTR_FOR_CLIENT_TABLE(rsFileGet)
  215 #define RS_FILE_GET_FS_FREE_SPACE NULLPTR_FOR_CLIENT_TABLE(rsFileGetFsFreeSpace)
  216 #define RS_FILE_LSEEK NULLPTR_FOR_CLIENT_TABLE(rsFileLseek)
  217 #define RS_FILE_MKDIR NULLPTR_FOR_CLIENT_TABLE(rsFileMkdir)
  218 #define RS_FILE_OPEN NULLPTR_FOR_CLIENT_TABLE(rsFileOpen)
  219 #define RS_FILE_OPENDIR NULLPTR_FOR_CLIENT_TABLE(rsFileOpendir)
  220 #define RS_FILE_PUT NULLPTR_FOR_CLIENT_TABLE(rsFilePut)
  221 #define RS_FILE_READ NULLPTR_FOR_CLIENT_TABLE(rsFileRead)
  222 #define RS_FILE_READDIR NULLPTR_FOR_CLIENT_TABLE(rsFileReaddir)
  223 #define RS_FILE_RENAME NULLPTR_FOR_CLIENT_TABLE(rsFileRename)
  224 #define RS_FILE_RMDIR NULLPTR_FOR_CLIENT_TABLE(rsFileRmdir)
  225 #define RS_FILE_STAGE_TO_CACHE NULLPTR_FOR_CLIENT_TABLE(rsFileStageToCache)
  226 #define RS_FILE_STAT NULLPTR_FOR_CLIENT_TABLE(rsFileStat)
  227 #define RS_FILE_SYNC_TO_ARCH NULLPTR_FOR_CLIENT_TABLE(rsFileSyncToArch)
  228 #define RS_FILE_TRUNCATE NULLPTR_FOR_CLIENT_TABLE(rsFileTruncate)
  229 #define RS_FILE_UNLINK NULLPTR_FOR_CLIENT_TABLE(rsFileUnlink)
  230 #define RS_FILE_WRITE NULLPTR_FOR_CLIENT_TABLE(rsFileWrite)
  231 #define RS_GENERAL_ADMIN NULLPTR_FOR_CLIENT_TABLE(rsGeneralAdmin)
  232 #define RS_GENERAL_ROW_INSERT NULLPTR_FOR_CLIENT_TABLE(rsGeneralRowInsert)
  233 #define RS_GENERAL_ROW_PURGE NULLPTR_FOR_CLIENT_TABLE(rsGeneralRowPurge)
  234 #define RS_GENERAL_UPDATE NULLPTR_FOR_CLIENT_TABLE(rsGeneralUpdate)
  235 #define RS_GEN_QUERY NULLPTR_FOR_CLIENT_TABLE(rsGenQuery)
  236 #define RS_GET_HIER_FOR_RESC NULLPTR_FOR_CLIENT_TABLE(rsGetHierarchyForResc)
  237 #define RS_GET_HIER_FROM_LEAF_ID NULLPTR_FOR_CLIENT_TABLE(rsGetHierFromLeafId)
  238 #define RS_GET_HOST_FOR_GET NULLPTR_FOR_CLIENT_TABLE(rsGetHostForGet)
  239 #define RS_GET_HOST_FOR_PUT NULLPTR_FOR_CLIENT_TABLE(rsGetHostForPut)
  240 #define RS_GET_LIMITED_PASSWORD NULLPTR_FOR_CLIENT_TABLE(rsGetLimitedPassword)
  241 #define RS_GET_MISC_SVR_INFO NULLPTR_FOR_CLIENT_TABLE(rsGetMiscSvrInfo)
  242 #define RS_GET_REMOTE_ZONE_RESC NULLPTR_FOR_CLIENT_TABLE(rsGetRemoteZoneResc)
  243 #define RS_GET_RESC_QUOTA NULLPTR_FOR_CLIENT_TABLE(rsGetRescQuota)
  244 #define RS_GET_TEMP_PASSWORD NULLPTR_FOR_CLIENT_TABLE(rsGetTempPassword)
  245 #define RS_GET_TEMP_PASSWORD_FOR_OTHER NULLPTR_FOR_CLIENT_TABLE(rsGetTempPasswordForOther)
  246 #define RS_GET_XMSG_TICKET NULLPTR_FOR_CLIENT_TABLE(rsGetXmsgTicket)
  247 #define RS_IES_CLIENT_HINTS NULLPTR_FOR_CLIENT_TABLE(rsClientHints)
  248 #define RS_L3_FILE_GET_SINGLE_BUF NULLPTR_FOR_CLIENT_TABLE(rsL3FileGetSingleBuf)
  249 #define RS_L3_FILE_PUT_SINGLE_BUF NULLPTR_FOR_CLIENT_TABLE(rsL3FilePutSingleBuf)
  250 #define RS_MOD_ACCESS_CONTROL NULLPTR_FOR_CLIENT_TABLE(rsModAccessControl)
  251 #define RS_MOD_AVU_METADATA NULLPTR_FOR_CLIENT_TABLE(rsModAVUMetadata)
  252 #define RS_MOD_COLL NULLPTR_FOR_CLIENT_TABLE(rsModColl)
  253 #define RS_MOD_DATA_OBJ_META NULLPTR_FOR_CLIENT_TABLE(rsModDataObjMeta)
  254 #define RS_OBJ_STAT NULLPTR_FOR_CLIENT_TABLE(rsObjStat)
  255 #define RS_OPEN_COLLECTION NULLPTR_FOR_CLIENT_TABLE(rsOpenCollection)
  256 #define RS_OPR_COMPLETE NULLPTR_FOR_CLIENT_TABLE(rsOprComplete)
  257 #define RS_PAM_AUTH_REQUEST NULLPTR_FOR_CLIENT_TABLE(rsPamAuthRequest)
  258 #define RS_PHY_BUNDLE_COLL NULLPTR_FOR_CLIENT_TABLE(rsPhyBundleColl)
  259 #define RS_PHY_PATH_REG NULLPTR_FOR_CLIENT_TABLE(rsPhyPathReg)
  260 #define RS_PROC_STAT NULLPTR_FOR_CLIENT_TABLE(rsProcStat)
  261 #define RS_QUERY_SPEC_COLL NULLPTR_FOR_CLIENT_TABLE(rsQuerySpecColl)
  262 #define RS_RCV_XMSG NULLPTR_FOR_CLIENT_TABLE(rsRcvXmsg)
  263 #define RS_READ_COLLECTION NULLPTR_FOR_CLIENT_TABLE(rsReadCollection)
  264 #define RS_REG_COLL NULLPTR_FOR_CLIENT_TABLE(rsRegColl)
  265 #define RS_REG_DATA_OBJ NULLPTR_FOR_CLIENT_TABLE(rsRegDataObj)
  266 #define RS_REG_REPLICA NULLPTR_FOR_CLIENT_TABLE(rsRegReplica)
  267 #define RS_RM_COLL NULLPTR_FOR_CLIENT_TABLE(rsRmColl)
  268 #define RS_RULE_EXEC_DEL NULLPTR_FOR_CLIENT_TABLE(rsRuleExecDel)
  269 #define RS_RULE_EXEC_MOD NULLPTR_FOR_CLIENT_TABLE(rsRuleExecMod)
  270 #define RS_RULE_EXEC_SUBMIT NULLPTR_FOR_CLIENT_TABLE(rsRuleExecSubmit)
  271 #define RS_SEND_XMSG NULLPTR_FOR_CLIENT_TABLE(rsSendXmsg)
  272 #define RS_SERVER_REPORT NULLPTR_FOR_CLIENT_TABLE(rsServerReport)
  273 #define RS_SET_ROUNDROBIN_CONTEXT NULLPTR_FOR_CLIENT_TABLE(rsSetRoundRobinContext)
  274 #define RS_SIMPLE_QUERY NULLPTR_FOR_CLIENT_TABLE(rsSimpleQuery)
  275 #define RS_SPECIFIC_QUERY NULLPTR_FOR_CLIENT_TABLE(rsSpecificQuery)
  276 #define RS_SSL_END NULLPTR_FOR_CLIENT_TABLE(rsSslEnd)
  277 #define RS_SSL_START NULLPTR_FOR_CLIENT_TABLE(rsSslStart)
  278 #define RS_STREAM_CLOSE NULLPTR_FOR_CLIENT_TABLE(rsStreamClose)
  279 #define RS_STREAM_READ NULLPTR_FOR_CLIENT_TABLE(rsStreamRead)
  280 #define RS_STRUCT_FILE_BUNDLE NULLPTR_FOR_CLIENT_TABLE(rsStructFileBundle)
  281 #define RS_STRUCT_FILE_EXTRACT NULLPTR_FOR_CLIENT_TABLE(rsStructFileExtract)
  282 #define RS_STRUCT_FILE_EXT_AND_REG NULLPTR_FOR_CLIENT_TABLE(rsStructFileExtAndReg)
  283 #define RS_STRUCT_FILE_SYNC NULLPTR_FOR_CLIENT_TABLE(rsStructFileSync)
  284 #define RS_SUB_STRUCT_FILE_CLOSE NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileClose)
  285 #define RS_SUB_STRUCT_FILE_CLOSEDIR NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileClosedir)
  286 #define RS_SUB_STRUCT_FILE_CREATE NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileCreate)
  287 #define RS_SUB_STRUCT_FILE_GET NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileGet)
  288 #define RS_SUB_STRUCT_FILE_LSEEK NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileLseek)
  289 #define RS_SUB_STRUCT_FILE_MKDIR NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileMkdir)
  290 #define RS_SUB_STRUCT_FILE_OPEN NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileOpen)
  291 #define RS_SUB_STRUCT_FILE_OPENDIR NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileOpendir)
  292 #define RS_SUB_STRUCT_FILE_PUT NULLPTR_FOR_CLIENT_TABLE(rsSubStructFilePut)
  293 #define RS_SUB_STRUCT_FILE_READ NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileRead)
  294 #define RS_SUB_STRUCT_FILE_READDIR NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileReaddir)
  295 #define RS_SUB_STRUCT_FILE_RENAME NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileRename)
  296 #define RS_SUB_STRUCT_FILE_RMDIR NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileRmdir)
  297 #define RS_SUB_STRUCT_FILE_STAT NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileStat)
  298 #define RS_SUB_STRUCT_FILE_TRUNCATE NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileTruncate)
  299 #define RS_SUB_STRUCT_FILE_UNLINK NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileUnlink)
  300 #define RS_SUB_STRUCT_FILE_WRITE NULLPTR_FOR_CLIENT_TABLE(rsSubStructFileWrite)
  301 #define RS_SYNC_MOUNTED_COLL NULLPTR_FOR_CLIENT_TABLE(rsSyncMountedColl)
  302 #define RS_TICKET_ADMIN NULLPTR_FOR_CLIENT_TABLE(rsTicketAdmin)
  303 #define RS_UNBUN_AND_REG_PHY_BUNFILE NULLPTR_FOR_CLIENT_TABLE(rsUnbunAndRegPhyBunfile)
  304 #define RS_UNREG_DATA_OBJ NULLPTR_FOR_CLIENT_TABLE(rsUnregDataObj)
  305 #define RS_USER_ADMIN NULLPTR_FOR_CLIENT_TABLE(rsUserAdmin)
  306 #define RS_ZONE_REPORT NULLPTR_FOR_CLIENT_TABLE(rsZoneReport)
  307 
  308 
  309 #if defined(CREATE_API_TABLE_FOR_SERVER) && !defined(CREATE_API_TABLE_FOR_CLIENT)
  310 static irods::apidef_t server_api_table_inp[] = {
  311 #elif !defined(CREATE_API_TABLE_FOR_SERVER) && defined(CREATE_API_TABLE_FOR_CLIENT)
  312 static irods::apidef_t client_api_table_inp[] = {
  313 #else
  314 #error "exactly one of {CREATE_API_TABLE_FOR_SERVER, CREATE_API_TABLE_FOR_CLIENT} must be defined"
  315 #endif
  316     {
  317         GET_MISC_SVR_INFO_AN, RODS_API_VERSION, NO_USER_AUTH, NO_USER_AUTH,
  318         NULL, 0, "MiscSvrInfo_PI", 0,
  319         boost::any(std::function<int(rsComm_t*,miscSvrInfo_t**)>(RS_GET_MISC_SVR_INFO)),
  320         "api_get_misc_svr_info", irods::clearInStruct_noop,
  321         (funcPtr)CALL_MISCSVRINFOOUT
  322     },
  323     {
  324         FILE_CREATE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  325         "fileOpenInp_PI", 0, "fileCreateOut_PI", 0,
  326         boost::any(std::function<int(rsComm_t*,fileCreateInp_t*,fileCreateOut_t**)>(RS_FILE_CREATE)),
  327         "api_file_create", clearFileOpenInp,
  328         (funcPtr)CALL_FILECREATEINP_FILECREATEOUT
  329     },
  330     {
  331         FILE_OPEN_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  332         "fileOpenInp_PI", 0, NULL, 0,
  333         boost::any(std::function<int(rsComm_t*,fileOpenInp_t*)>(RS_FILE_OPEN)),
  334         "api_file_open", clearFileOpenInp,
  335         (funcPtr)CALL_FILEOPENINP
  336     },
  337     {
  338         CHK_N_V_PATH_PERM_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  339         "fileOpenInp_PI", 0, NULL, 0,
  340         boost::any(std::function<int(rsComm_t*,fileOpenInp_t*)>(RS_CHK_NV_PATH_PERM)),
  341         "api_check_nv_path_perm", clearFileOpenInp,
  342         (funcPtr)CALL_FILEOPENINP
  343     },
  344     {
  345         FILE_WRITE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  346         "fileWriteInp_PI", 1, NULL, 0,
  347         boost::any(std::function<int(rsComm_t*,fileWriteInp_t*,bytesBuf_t*)>(RS_FILE_WRITE)),
  348         "api_file_write", irods::clearInStruct_noop,
  349         (funcPtr)CALL_FILEWRITEINP_BYTESBUFINP
  350     },
  351     {
  352         FILE_CLOSE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  353         "fileCloseInp_PI", 0, NULL, 0,
  354         boost::any(std::function<int(rsComm_t*,fileCloseInp_t*)>(RS_FILE_CLOSE)),
  355         "api_file_close", irods::clearInStruct_noop,
  356         (funcPtr)CALL_FILECLOSEINP
  357     },
  358     {
  359         FILE_LSEEK_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  360         "fileLseekInp_PI", 0, "fileLseekOut_PI", 0,
  361         boost::any(std::function<int(rsComm_t*,fileLseekInp_t*,fileLseekOut_t**)>(RS_FILE_LSEEK)),
  362         "api_file_lseek", irods::clearInStruct_noop,
  363         (funcPtr)CALL_FILELSEEKINP_FILELSEEKOUT
  364     },
  365     {
  366         FILE_READ_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  367         "fileReadInp_PI", 0, NULL, 1,
  368         boost::any(std::function<int(rsComm_t*,fileReadInp_t*,bytesBuf_t*)>(RS_FILE_READ)),
  369         "api_file_read", irods::clearInStruct_noop,
  370         (funcPtr)CALL_FILEREADINP_BYTESBUFOUT
  371     },
  372     {
  373         FILE_UNLINK_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  374         "fileUnlinkInp_PI", 0, NULL, 0,
  375         boost::any(std::function<int(rsComm_t*,fileUnlinkInp_t*)>(RS_FILE_UNLINK)),
  376         "api_file_unlink", irods::clearInStruct_noop,
  377         (funcPtr)CALL_FILEUNLINKINP
  378     },
  379     {
  380         FILE_MKDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  381         "fileMkdirInp_PI", 0, NULL, 0,
  382         boost::any(std::function<int(rsComm_t*,fileMkdirInp_t*)>(RS_FILE_MKDIR)),
  383         "api_file_mkdir", irods::clearInStruct_noop,
  384         (funcPtr)CALL_FILEMKDIRINP
  385     },
  386     {
  387         FILE_CHMOD_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  388         "fileChmodInp_PI", 0, NULL, 0,
  389         boost::any(std::function<int(rsComm_t*,fileChmodInp_t*)>(RS_FILE_CHMOD)),
  390         "api_file_chmod", irods::clearInStruct_noop,
  391         (funcPtr)CALL_FILECHMODINP
  392     },
  393     {
  394         FILE_RMDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  395         "fileRmdirInp_PI", 0, NULL, 0,
  396         boost::any(std::function<int(rsComm_t*,fileRmdirInp_t*)>(RS_FILE_RMDIR)),
  397         "api_file_rmdir", irods::clearInStruct_noop,
  398         (funcPtr)CALL_FILERMDIRINP
  399     },
  400     {
  401         FILE_STAT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  402         "fileStatInp_PI", 0,  "RODS_STAT_T_PI", 0,
  403         boost::any(std::function<int(rsComm_t*,fileStatInp_t*,rodsStat_t**)>(RS_FILE_STAT)),
  404         "api_file_stat", irods::clearInStruct_noop,
  405         (funcPtr)CALL_FILESTATINP_RODSSTATOUT
  406 
  407     },
  408     {
  409         FILE_GET_FS_FREE_SPACE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  410         "fileGetFsFreeSpaceInp_PI", 0, "fileGetFsFreeSpaceOut_PI", 0,
  411         boost::any(std::function<int(rsComm_t*,fileGetFsFreeSpaceInp_t*,fileGetFsFreeSpaceOut_t**)>(RS_FILE_GET_FS_FREE_SPACE)),
  412         "api_file_get_fs_free_space", irods::clearInStruct_noop,
  413         (funcPtr)CALL_FILEGETFREESPACEINP_FILEGETFREESPACEOUT
  414     },
  415     {
  416         FILE_OPENDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  417         "fileOpendirInp_PI", 0, NULL, 0,
  418         boost::any(std::function<int(rsComm_t*,fileOpendirInp_t*)>(RS_FILE_OPENDIR)),
  419         "api_file_opendir", irods::clearInStruct_noop,
  420         (funcPtr)CALL_FILEOPENDIRINP
  421     },
  422     {
  423         FILE_CLOSEDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  424         "fileClosedirInp_PI", 0, NULL, 0,
  425         boost::any(std::function<int(rsComm_t*,fileClosedirInp_t*)>(RS_FILE_CLOSEDIR)),
  426         "api_file_closedir", irods::clearInStruct_noop,
  427         (funcPtr)CALL_FILECLOSEDIRINP
  428     },
  429     {
  430         FILE_READDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  431         "fileReaddirInp_PI", 0, "RODS_DIRENT_T_PI", 0,
  432         boost::any(std::function<int(rsComm_t*,fileReaddirInp_t*,rodsDirent_t**)>(RS_FILE_READDIR)),
  433         "api_file_readdir", irods::clearInStruct_noop,
  434         (funcPtr)CALL_FILEREADDIRINP_RODSDIRENTOUT
  435     },
  436     {
  437         FILE_RENAME_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  438         "fileRenameInp_PI", 0, "fileRenameOut_PI", 0,
  439         boost::any(std::function<int(rsComm_t*,fileRenameInp_t*,fileRenameOut_t**)>(RS_FILE_RENAME)),
  440         "api_file_rename", irods::clearInStruct_noop,
  441         (funcPtr)CALL_FILERENAMEINP_FILERENAMEOUT
  442     },
  443     {
  444         FILE_TRUNCATE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  445         "fileOpenInp_PI", 0, NULL, 0,
  446         boost::any(std::function<int(rsComm_t*,fileOpenInp_t*)>(RS_FILE_TRUNCATE)),
  447         "api_file_truncate", clearFileOpenInp,
  448         (funcPtr)CALL_FILEOPENINP
  449     },
  450     {
  451         FILE_PUT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  452         "fileOpenInp_PI", 1, "filePutOut_PI", 0,
  453         boost::any(std::function<int(rsComm_t*,fileOpenInp_t*,bytesBuf_t*,filePutOut_t**)>(RS_FILE_PUT)),
  454         "api_file_put", clearFileOpenInp,
  455         (funcPtr)CALL_FILEOPENINP_BYTESBUFINP_FILEPUTOUT
  456     },
  457     {
  458         FILE_GET_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  459         "fileOpenInp_PI", 0, NULL, 1,
  460         boost::any(std::function<int(rsComm_t*,fileOpenInp_t*,bytesBuf_t*)>(RS_FILE_GET)),
  461         "api_file_get", clearFileOpenInp,
  462         (funcPtr)CALL_FILEOPENINP_BYTESBUFOUT
  463     },
  464     {
  465         FILE_STAGE_TO_CACHE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  466         "fileStageSyncInp_PI", 0, NULL, 0,
  467         boost::any(std::function<int(rsComm_t*,fileStageSyncInp_t*)>(RS_FILE_STAGE_TO_CACHE)),
  468         "api_file_stage_to_cache", irods::clearInStruct_noop,
  469         (funcPtr)CALL_FILESTAGESYNCINP
  470     },
  471     {
  472         FILE_SYNC_TO_ARCH_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  473         "fileStageSyncInp_PI", 0, "fileSyncOut_PI", 0,
  474         boost::any(std::function<int(rsComm_t*,fileStageSyncInp_t*,fileSyncOut_t**)>(RS_FILE_SYNC_TO_ARCH)),
  475         "api_file_sync_to_arch", irods::clearInStruct_noop,
  476         (funcPtr)CALL_FILESTAGESYNCINP_FILESYNCOUT
  477     },
  478     {
  479         DATA_OBJ_CREATE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  480         "DataObjInp_PI", 0, NULL, 0,
  481         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_DATA_OBJ_CREATE)),
  482         "api_data_obj_create", clearDataObjInp,
  483         (funcPtr)CALL_DATAOBJINP
  484     },
  485     {
  486         DATA_OBJ_OPEN_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  487         "DataObjInp_PI", 0, NULL, 0,
  488         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_DATA_OBJ_OPEN)),
  489         "api_data_obj_open", clearDataObjInp,
  490         (funcPtr)CALL_DATAOBJINP
  491     },
  492     {
  493         DATA_OBJ_READ_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  494         "OpenedDataObjInp_PI", 0, NULL, 1,
  495         boost::any(std::function<int(rsComm_t*,openedDataObjInp_t*,bytesBuf_t*)>(RS_DATA_OBJ_READ)),
  496         "api_data_obj_read", irods::clearInStruct_noop,
  497         (funcPtr)CALL_OPENEDDATAOBJINP_BYTESBUFOUT
  498     },
  499     {
  500         DATA_OBJ_WRITE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  501         "OpenedDataObjInp_PI", 1, NULL, 0,
  502         boost::any(std::function<int(rsComm_t*,openedDataObjInp_t*,bytesBuf_t*)>(RS_DATA_OBJ_WRITE)),
  503         "api_data_obj_write", irods::clearInStruct_noop,
  504         (funcPtr)CALL_OPENEDDATAOBJINP_BYTESBUFOUT
  505 
  506     },
  507     {
  508         DATA_OBJ_CLOSE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  509         "OpenedDataObjInp_PI", 0, NULL, 0,
  510         boost::any(std::function<int(rsComm_t*,openedDataObjInp_t*)>(RS_DATA_OBJ_CLOSE)),
  511         "api_data_obj_close", irods::clearInStruct_noop,
  512         (funcPtr)CALL_OPENEDDATAOBJINP
  513     },
  514     {
  515         DATA_OBJ_PUT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  516         "DataObjInp_PI", 1,  "PortalOprOut_PI", 0,
  517         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,bytesBuf_t*,portalOprOut_t**)>(RS_DATA_OBJ_PUT)),
  518         "api_data_obj_put", clearDataObjInp,
  519         (funcPtr)CALL_DATAOBJINP_BYTESBUFINP_PORTALOPROUT
  520     },
  521     {
  522         DATA_OBJ_GET_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  523         "DataObjInp_PI", 0, "PortalOprOut_PI", 1,
  524         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,portalOprOut_t**,bytesBuf_t*)>(RS_DATA_OBJ_GET)),
  525         "api_data_obj_get", clearDataObjInp,
  526         (funcPtr)CALL_DATAOBJINP_PORTALOPROUT_BYTESBUFOUT
  527     },
  528     {
  529         DATA_OBJ_REPL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  530         "DataObjInp_PI", 0, "TransferStat_PI", 0,
  531         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,transferStat_t**)>(RS_DATA_OBJ_REPL)),
  532         "api_data_obj_repl", clearDataObjInp,
  533         (funcPtr)CALL_DATAOBJINP_TRANSFERSTATOUT
  534     },
  535     {
  536         DATA_OBJ_LSEEK_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  537         "OpenedDataObjInp_PI", 0, "fileLseekOut_PI", 0,
  538         boost::any(std::function<int(rsComm_t*,openedDataObjInp_t*,fileLseekOut_t**)>(RS_DATA_OBJ_LSEEK)),
  539         "api_data_obj_lseek", irods::clearInStruct_noop,
  540         (funcPtr)CALL_OPENEDDATAOBJINP_FILELSEEKOUT
  541     },
  542     {
  543         DATA_OBJ_COPY_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  544         "DataObjCopyInp_PI", 0, "TransferStat_PI", 0,
  545         boost::any(std::function<int(rsComm_t*,dataObjCopyInp_t*,transferStat_t**)>(RS_DATA_OBJ_COPY)),
  546         "api_data_obj_copy", clearDataObjCopyInp,
  547         (funcPtr)CALL_DATAOBJCOPYINP_TRANFERSTATOUT
  548     },
  549     {
  550         DATA_OBJ_UNLINK_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  551         "DataObjInp_PI", 0, NULL, 0,
  552         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_DATA_OBJ_UNLINK)),
  553         "api_data_obj_unlink", clearDataObjInp,
  554         (funcPtr)CALL_DATAOBJINP
  555     },
  556     {
  557         DATA_PUT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  558         "DataOprInp_PI", 0, "PortalOprOut_PI", 0,
  559         boost::any(std::function<int(rsComm_t*,dataOprInp_t*,portalOprOut_t**)>(RS_DATA_PUT)),
  560         "api_data_put", irods::clearInStruct_noop,
  561         (funcPtr)CALL_DATAOPRINP_PORTALOPROUT
  562     },
  563     {
  564         DATA_GET_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  565         "DataOprInp_PI", 0, "PortalOprOut_PI", 0,
  566         boost::any(std::function<int(rsComm_t*,dataOprInp_t*,portalOprOut_t**)>(RS_DATA_GET)),
  567         "api_data_get", irods::clearInStruct_noop,
  568         (funcPtr)CALL_DATAOPRINP_PORTALOPROUT
  569     },
  570     {
  571         DATA_COPY_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  572         "DataCopyInp_PI", 0, NULL, 0,
  573         boost::any(std::function<int(rsComm_t*,dataCopyInp_t*)>(RS_DATA_COPY)),
  574         "api_data_copy", irods::clearInStruct_noop,
  575         (funcPtr)CALL_DATACOPYINP
  576     },
  577     {
  578         SIMPLE_QUERY_AN, RODS_API_VERSION, LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
  579         "simpleQueryInp_PI", 0,  "simpleQueryOut_PI", 0,
  580         boost::any(std::function<int(rsComm_t*,simpleQueryInp_t*,simpleQueryOut_t**)>(RS_SIMPLE_QUERY)),
  581         "api_simple_query", irods::clearInStruct_noop,
  582         (funcPtr)CALL_SIMPLEQUERYINP_SIMPLEQUERYOUT
  583     },
  584     {
  585         GENERAL_ADMIN_AN, RODS_API_VERSION, LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
  586         "generalAdminInp_PI", 0, NULL, 0,
  587         boost::any(std::function<int(rsComm_t*,generalAdminInp_t*)>(RS_GENERAL_ADMIN)),
  588         "api_general_admin", irods::clearInStruct_noop,
  589         (funcPtr)CALL_GENERALADMININP
  590     },
  591     {
  592         GEN_QUERY_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  593         "GenQueryInp_PI", 0, "GenQueryOut_PI", 0,
  594         boost::any(std::function<int(rsComm_t*,genQueryInp_t*,genQueryOut_t**)>(RS_GEN_QUERY)),
  595         "api_gen_query", clearGenQueryInp,
  596         (funcPtr)CALL_GENQUERYINP_GENQUERYOUT
  597     },
  598     {
  599         AUTH_REQUEST_AN, RODS_API_VERSION, NO_USER_AUTH | XMSG_SVR_ALSO, NO_USER_AUTH | XMSG_SVR_ALSO,
  600         NULL, 0,  "authRequestOut_PI", 0,
  601         boost::any(std::function<int(rsComm_t*,authRequestOut_t**)>(RS_AUTH_REQUEST)),
  602         "api_auth_request", irods::clearInStruct_noop,
  603         (funcPtr)CALL_AUTHREQUESTOUT
  604 
  605     },
  606     {
  607         AUTH_RESPONSE_AN, RODS_API_VERSION, NO_USER_AUTH | XMSG_SVR_ALSO, NO_USER_AUTH | XMSG_SVR_ALSO,
  608         "authResponseInp_PI", 0, NULL, 0,
  609         boost::any(std::function<int(rsComm_t*,authResponseInp_t*)>(RS_AUTH_RESPONSE)),
  610         "api_auth_response", clearAuthResponseInp,
  611         (funcPtr)CALL_AUTHRESPONSEINP
  612 
  613     },
  614     /* AUTH_CHECK might need to be NO_USER_AUTH but it would be better
  615     if we could restrict it some; if the servers can authenticate
  616     themselves first (if they need to eventually, probably, anyway)
  617     then this should work OK.  If not, we can change REMOTE_USER_AUTH
  618     to NO_USER_AUTH.
  619     Need to set it to NO_USER_AUTH for cross zone auth to prevent ping-pong
  620     effect */
  621     {
  622         AUTH_CHECK_AN, RODS_API_VERSION, NO_USER_AUTH, NO_USER_AUTH,
  623         "authCheckInp_PI", 0,  "authCheckOut_PI", 0,
  624         boost::any(std::function<int(rsComm_t*,authCheckInp_t*,authCheckOut_t**)>(RS_AUTH_CHECK)),
  625         "api_auth_check", irods::clearInStruct_noop,
  626         (funcPtr)CALL_AUTHCHECKINP_AUTHCHECKOUT
  627     },
  628     {
  629         END_TRANSACTION_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  630         "endTransactionInp_PI", 0, NULL, 0,
  631         boost::any(std::function<int(rsComm_t*,endTransactionInp_t*)>(RS_END_TRANSACTION)),
  632         "api_end_transaction", irods::clearInStruct_noop,
  633         (funcPtr)CALL_ENDTRANSACTIONINP
  634     },
  635     {
  636         SPECIFIC_QUERY_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  637         "specificQueryInp_PI", 0, "GenQueryOut_PI", 0,
  638         boost::any(std::function<int(rsComm_t*,specificQueryInp_t*,genQueryOut_t**)>(RS_SPECIFIC_QUERY)),
  639         "api_specific_query", irods::clearInStruct_noop,
  640         (funcPtr)CALL_SPECIFICQUERYINP_GENQUERYOUT
  641     },
  642     {
  643         TICKET_ADMIN_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  644         "ticketAdminInp_PI", 0, NULL, 0,
  645         boost::any(std::function<int(rsComm_t*,ticketAdminInp_t*)>(RS_TICKET_ADMIN)),
  646         "api_ticket_admin", irods::clearInStruct_noop,
  647         (funcPtr)CALL_TICKETADMININP
  648     },
  649     {
  650         GET_TEMP_PASSWORD_FOR_OTHER_AN, RODS_API_VERSION,
  651         LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
  652         "getTempPasswordForOtherInp_PI", 0,  "getTempPasswordForOtherOut_PI", 0,
  653         boost::any(std::function<int(rsComm_t*,getTempPasswordForOtherInp_t*,getTempPasswordForOtherOut_t**)>(RS_GET_TEMP_PASSWORD_FOR_OTHER)),
  654         "api_get_temp_password_for_other", irods::clearInStruct_noop,
  655         (funcPtr)CALL_GETTEMPPASSWORDFOROTHERINP_GETTEMPPASSWORDFOROTHEROUT
  656     },
  657     {
  658         PAM_AUTH_REQUEST_AN, RODS_API_VERSION,
  659         NO_USER_AUTH | XMSG_SVR_ALSO, NO_USER_AUTH | XMSG_SVR_ALSO,
  660         "pamAuthRequestInp_PI", 0,  "pamAuthRequestOut_PI", 0,
  661         boost::any(std::function<int(rsComm_t*,pamAuthRequestInp_t*,pamAuthRequestOut_t**)>(RS_PAM_AUTH_REQUEST)),
  662         "api_pam_auth_request", irods::clearInStruct_noop,
  663         (funcPtr)CALL_PAMAUTHREQUESTINP_PAMAUTHREQUESTOUT
  664     },
  665     {
  666         GET_LIMITED_PASSWORD_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  667         "getLimitedPasswordInp_PI", 0,  "getLimitedPasswordOut_PI", 0,
  668         boost::any(std::function<int(rsComm_t*,getLimitedPasswordInp_t*,getLimitedPasswordOut_t**)>(RS_GET_LIMITED_PASSWORD)),
  669         "api_get_limited_password", irods::clearInStruct_noop,
  670         (funcPtr)CALL_GETLIMITEDPASSWORDINP_GETLIMITEDPASSWORDOUT
  671     },
  672     {
  673         OPEN_COLLECTION_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  674         "CollInpNew_PI", 0, NULL, 0,
  675         boost::any(std::function<int(rsComm_t*,collInp_t*)>(RS_OPEN_COLLECTION)),
  676         "api_open_collection", clearCollInp,
  677         (funcPtr)CALL_COLLINP
  678     },
  679     {
  680         READ_COLLECTION_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  681         "INT_PI", 0, "CollEnt_PI", 0,
  682         boost::any(std::function<int(rsComm_t*,int*, collEnt_t**)>(RS_READ_COLLECTION)),
  683         "api_read_collection", irods::clearInStruct_noop,
  684         (funcPtr)CALL_INTP_COLLENTOUT
  685     },
  686     {
  687         USER_ADMIN_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  688         "userAdminInp_PI", 0, NULL, 0,
  689         boost::any(std::function<int(rsComm_t*,userAdminInp_t*)>(RS_USER_ADMIN)),
  690         "api_user_admin", irods::clearInStruct_noop,
  691         (funcPtr)CALL_USERADMININP
  692     },
  693     {
  694         GENERAL_ROW_INSERT_AN, RODS_API_VERSION,
  695         LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
  696         "generalRowInsertInp_PI", 0, NULL, 0,
  697         boost::any(std::function<int(rsComm_t*,generalRowInsertInp_t*)>(RS_GENERAL_ROW_INSERT)),
  698         "api_general_row_insert", irods::clearInStruct_noop,
  699         (funcPtr)CALL_GENERALROWINSERTINP
  700     },
  701     {
  702         GENERAL_ROW_PURGE_AN, RODS_API_VERSION,
  703         LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
  704         "generalRowPurgeInp_PI", 0, NULL, 0,
  705         boost::any(std::function<int(rsComm_t*,generalRowPurgeInp_t*)>(RS_GENERAL_ROW_PURGE)),
  706         "api_general_row_purge", irods::clearInStruct_noop,
  707         (funcPtr)CALL_GENERALROWPURGEINP
  708     },
  709     {
  710         CLOSE_COLLECTION_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  711         "INT_PI", 0, NULL, 0,
  712         boost::any(std::function<int(rsComm_t*,int*)>(RS_CLOSE_COLLECTION)),
  713         "close_collection", irods::clearInStruct_noop,
  714         (funcPtr)CALL_INTP
  715     },
  716     {
  717         COLL_REPL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  718         "CollInpNew_PI", 0, "CollOprStat_PI", 0,
  719         boost::any(std::function<int(rsComm_t*,collInp_t*,collOprStat_t**)>(RS_COLL_REPL)),
  720         "api_coll_repl", clearCollInp,
  721         (funcPtr)CALL_COLLINP_COLLOPRSTATOUT
  722     },
  723     {
  724         RM_COLL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  725         "CollInpNew_PI", 0, "CollOprStat_PI", 0,
  726         boost::any(std::function<int(rsComm_t*,collInp_t*,collOprStat_t**)>(RS_RM_COLL)),
  727         "api_rm_coll", clearCollInp,
  728         (funcPtr)CALL_COLLINP_COLLOPRSTATOUT
  729     },
  730     {
  731         MOD_AVU_METADATA_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  732         "ModAVUMetadataInp_PI", 0, NULL, 0,
  733         boost::any(std::function<int(rsComm_t*,modAVUMetadataInp_t*)>(RS_MOD_AVU_METADATA)),
  734         "api_mod_avu_metadata", clearModAVUMetadataInp,
  735         (funcPtr)CALL_MODAVUMETADATAINP
  736     },
  737     {
  738         MOD_ACCESS_CONTROL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  739         "modAccessControlInp_PI", 0, NULL, 0,
  740         boost::any(std::function<int(rsComm_t*,modAccessControlInp_t*)>(RS_MOD_ACCESS_CONTROL)),
  741         "api_mod_access_control", irods::clearInStruct_noop,
  742         (funcPtr)CALL_MODACCESSCONTROLINP
  743     },
  744     {
  745         RULE_EXEC_MOD_AN, RODS_API_VERSION, LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
  746         "RULE_EXEC_MOD_INP_PI", 0, NULL, 0,
  747         boost::any(std::function<int(rsComm_t*,ruleExecModInp_t*)>(RS_RULE_EXEC_MOD)),
  748         "api_rule_exec_mod", irods::clearInStruct_noop,
  749         (funcPtr)CALL_RULEEXECMODINP
  750     },
  751     {
  752         GET_TEMP_PASSWORD_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  753         NULL, 0,  "getTempPasswordOut_PI", 0,
  754         boost::any(std::function<int(rsComm_t*,getTempPasswordOut_t**)>(RS_GET_TEMP_PASSWORD)),
  755         "api_get_temp_password", irods::clearInStruct_noop,
  756         (funcPtr)CALL_GETTEMPPASSWORDOUT
  757     },
  758     {
  759         GENERAL_UPDATE_AN, RODS_API_VERSION,
  760         LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
  761         "GeneralUpdateInp_PI", 0, NULL, 0,
  762         boost::any(std::function<int(rsComm_t*,generalUpdateInp_t*)>(RS_GENERAL_UPDATE)),
  763         "api_general_update", irods::clearInStruct_noop,
  764         (funcPtr)CALL_GENERALUPDATEINP
  765     },
  766     {
  767         MOD_DATA_OBJ_META_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  768         "ModDataObjMeta_PI", 0, NULL, 0,
  769         boost::any(std::function<int(rsComm_t*,modDataObjMeta_t*)>(RS_MOD_DATA_OBJ_META)),
  770         "api_mod_data_obj_meta", clearModDataObjMetaInp,
  771         (funcPtr)CALL_MODDATAOBJMETAINP
  772     },
  773     {
  774         RULE_EXEC_SUBMIT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  775         "RULE_EXEC_SUBMIT_INP_PI", 0, "IRODS_STR_PI", 0,
  776         boost::any(std::function<int(rsComm_t*,ruleExecSubmitInp_t*,char**)>(RS_RULE_EXEC_SUBMIT)),
  777         "api_rule_exec_submit", irods::clearInStruct_noop,
  778         (funcPtr)CALL_RULEEXECSUBMITINP_CHAROUT
  779     },
  780     {
  781         RULE_EXEC_DEL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, LOCAL_USER_AUTH,
  782         "RULE_EXEC_DEL_INP_PI", 0, NULL, 0,
  783         boost::any(std::function<int(rsComm_t*,ruleExecDelInp_t*)>(RS_RULE_EXEC_DEL)),
  784         "api_rule_exec_del", irods::clearInStruct_noop,
  785         (funcPtr)CALL_RULEEXECDELINP
  786     },
  787     {
  788         EXEC_MY_RULE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  789         "ExecMyRuleInp_PI", 0, "MsParamArray_PI", 0,
  790         boost::any(std::function<int(rsComm_t*,execMyRuleInp_t*,msParamArray_t**)>(RS_EXEC_MY_RULE)),
  791         "api_exec_my_rule", irods::clearInStruct_noop,
  792         (funcPtr)CALL_EXECMYRULEINP_MSPARAMARRAYOUT
  793     },
  794     {
  795         OPR_COMPLETE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  796         "INT_PI", 0, NULL, 0,
  797         boost::any(std::function<int(rsComm_t*,int*)>(RS_OPR_COMPLETE)),
  798         "api_opr_complete", irods::clearInStruct_noop,
  799         (funcPtr)CALL_INTP
  800     },
  801     {
  802         DATA_OBJ_RENAME_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  803         "DataObjCopyInp_PI", 0, NULL, 0,
  804         boost::any(std::function<int(rsComm_t*,dataObjCopyInp_t*)>(RS_DATA_OBJ_RENAME)),
  805         "api_data_obj_rename", clearDataObjCopyInp,
  806         (funcPtr)CALL_DATAOBJCOPYINP
  807     },
  808     {
  809         DATA_OBJ_RSYNC_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  810         "DataObjInp_PI", 0, "MsParamArray_PI", 0,
  811         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,msParamArray_t**)>(RS_DATA_OBJ_RSYNC)),
  812         "api_data_obj_rsync", clearDataObjInp,
  813         (funcPtr)  CALL_DATAOBJINP_MSPARAMARRAYOUT
  814     },
  815     {
  816         DATA_OBJ_CHKSUM_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  817         "DataObjInp_PI", 0, "STR_PI", 0,
  818         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,char**)>(RS_DATA_OBJ_CHKSUM)),
  819         "api_data_obj_chksum", clearDataObjInp,
  820         (funcPtr)CALL_DATAOBJINP_CHAROUT
  821     },
  822     {
  823         PHY_PATH_REG_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  824         "DataObjInp_PI", 0, NULL, 0,
  825         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_PHY_PATH_REG)),
  826         "api_phy_path_reg", clearDataObjInp,
  827         (funcPtr)CALL_DATAOBJINP
  828     },
  829     {
  830         DATA_OBJ_PHYMV_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  831         "DataObjInp_PI", 0, "TransferStat_PI", 0,
  832         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,transferStat_t**)>(RS_DATA_OBJ_PHYMV)),
  833         "api_data_obj_phymv", clearDataObjInp,
  834         (funcPtr)CALL_DATAOBJINP_TRANSFERSTATOUT
  835     },
  836     {
  837         DATA_OBJ_TRIM_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  838         "DataObjInp_PI", 0, NULL, 0,
  839         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_DATA_OBJ_TRIM)),
  840         "api_data_obj_trim", clearDataObjInp,
  841         (funcPtr)CALL_DATAOBJINP
  842     },
  843     {
  844         OBJ_STAT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  845         "DataObjInp_PI", 0, "RodsObjStat_PI", 0,
  846         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,rodsObjStat_t**)>(RS_OBJ_STAT)),
  847         "api_obj_stat", clearDataObjInp,
  848         (funcPtr)CALL_DATAOBJINP_RODSOBJSTATOUT
  849     },
  850     {
  851         EXEC_CMD_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  852         "ExecCmd_PI", 0, "ExecCmdOut_PI", 0,
  853         boost::any(std::function<int(rsComm_t*,execCmd_t*,execCmdOut_t**)>(RS_EXEC_CMD)),
  854         "api_exec_cmd", irods::clearInStruct_noop,
  855         (funcPtr)CALL_EXECCMDINP_EXECCMDOUT
  856     },
  857     {
  858         STREAM_CLOSE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  859         "fileCloseInp_PI", 0, NULL, 0,
  860         boost::any(std::function<int(rsComm_t*,fileCloseInp_t*)>(RS_STREAM_CLOSE)),
  861         "api_stream_close", irods::clearInStruct_noop,
  862         (funcPtr)CALL_FILECLOSEINP
  863     },
  864     {
  865         GET_HOST_FOR_GET_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  866         "DataObjInp_PI", 0, "STR_PI", 0,
  867         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,char**)>(RS_GET_HOST_FOR_GET)),
  868         "api_get_host_for_get", clearDataObjInp,
  869         (funcPtr)CALL_DATAOBJINP_CHAROUT
  870     },
  871     {
  872         DATA_OBJ_LOCK_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  873         "DataObjInp_PI", 0, NULL, 0,
  874         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_DATA_OBJ_LOCK)),
  875         "api_data_obj_lock", clearDataObjInp,
  876         (funcPtr)CALL_DATAOBJINP
  877     },
  878     {
  879         DATA_OBJ_UNLOCK_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  880         "DataObjInp_PI", 0, NULL, 0,
  881         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_DATA_OBJ_UNLOCK)),
  882         "api_data_obj_unlock", clearDataObjInp,
  883         (funcPtr)CALL_DATAOBJINP
  884     },
  885     {
  886         SUB_STRUCT_FILE_CREATE_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  887         REMOTE_PRIV_USER_AUTH, "SubFile_PI", 0, NULL, 0,
  888         boost::any(std::function<int(rsComm_t*,subFile_t*)>(RS_SUB_STRUCT_FILE_CREATE)),
  889         "api_sub_struct_file_create", irods::clearInStruct_noop,
  890         (funcPtr)CALL_SUBFILEINP
  891     },
  892     {
  893         SUB_STRUCT_FILE_OPEN_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  894         REMOTE_PRIV_USER_AUTH, "SubFile_PI", 0, NULL, 0,
  895         boost::any(std::function<int(rsComm_t*,subFile_t*)>(RS_SUB_STRUCT_FILE_OPEN)),
  896         "api_sub_struct_file_open", irods::clearInStruct_noop,
  897         (funcPtr)CALL_SUBFILEINP
  898     },
  899     {
  900         SUB_STRUCT_FILE_READ_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  901         REMOTE_PRIV_USER_AUTH, "SubStructFileFdOpr_PI", 0, NULL, 1,
  902         boost::any(std::function<int(rsComm_t*,subStructFileFdOprInp_t*,bytesBuf_t*)>(RS_SUB_STRUCT_FILE_READ)),
  903         "api_sub_struct_file_read", irods::clearInStruct_noop,
  904         (funcPtr)CALL_SUBSTRUCTFILEFDOPRINP_BYTESBUFOUT
  905     },
  906     {
  907         SUB_STRUCT_FILE_WRITE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
  908         "SubStructFileFdOpr_PI", 1, NULL, 0,
  909         boost::any(std::function<int(rsComm_t*,subStructFileFdOprInp_t*,bytesBuf_t*)>(RS_SUB_STRUCT_FILE_WRITE)),
  910         "api_sub_struct_file_write", irods::clearInStruct_noop,
  911         (funcPtr)CALL_SUBSTRUCTFILEFDOPRINP_BYTESBUFOUT
  912     },
  913     {
  914         SUB_STRUCT_FILE_CLOSE_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  915         REMOTE_PRIV_USER_AUTH, "SubStructFileFdOpr_PI", 0, NULL, 0,
  916         boost::any(std::function<int(rsComm_t*,subStructFileFdOprInp_t*)>(RS_SUB_STRUCT_FILE_CLOSE)),
  917         "api_sub_struct_file_close", irods::clearInStruct_noop,
  918         (funcPtr)CALL_SUBSTRUCTFILEFDOPRINP
  919     },
  920     {
  921         SUB_STRUCT_FILE_UNLINK_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  922         REMOTE_PRIV_USER_AUTH, "SubFile_PI", 0, NULL, 0,
  923         boost::any(std::function<int(rsComm_t*,subFile_t*)>(RS_SUB_STRUCT_FILE_UNLINK)),
  924         "api_sub_struct_file_unlink", irods::clearInStruct_noop,
  925         (funcPtr)CALL_SUBFILEINP
  926     },
  927     {
  928         SUB_STRUCT_FILE_STAT_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  929         REMOTE_PRIV_USER_AUTH, "SubFile_PI", 0, "RODS_STAT_T_PI", 0,
  930         boost::any(std::function<int(rsComm_t*,subFile_t*,rodsStat_t**)>(RS_SUB_STRUCT_FILE_STAT)),
  931         "api_sub_struct_file_stat", irods::clearInStruct_noop,
  932         (funcPtr)CALL_SUBFILEINP_RODSSTATOUT
  933     },
  934     {
  935         SUB_STRUCT_FILE_LSEEK_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  936         REMOTE_PRIV_USER_AUTH, "SubStructFileLseekInp_PI", 0, "fileLseekOut_PI", 0,
  937         boost::any(std::function<int(rsComm_t*,subStructFileLseekInp_t*,fileLseekOut_t**)>(RS_SUB_STRUCT_FILE_LSEEK)),
  938         "api_sub_struct_file_lseek", irods::clearInStruct_noop,
  939         (funcPtr)CALL_SUBSTRUCTLSEEKINP_FILELSEEKOUT
  940     },
  941     {
  942         SUB_STRUCT_FILE_RENAME_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  943         REMOTE_PRIV_USER_AUTH, "SubStructFileRenameInp_PI", 0, NULL, 0,
  944         boost::any(std::function<int(rsComm_t*,subStructFileRenameInp_t*)>(RS_SUB_STRUCT_FILE_RENAME)),
  945         "api_sub_struct_file_rename", irods::clearInStruct_noop,
  946         (funcPtr)CALL_SUBSTRUCTFILERENAMEINP
  947     },
  948     {
  949         QUERY_SPEC_COLL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  950         "DataObjInp_PI", 0, "GenQueryOut_PI", 0,
  951         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,genQueryOut_t**)>(RS_QUERY_SPEC_COLL)),
  952         "api_query_spec_coll", clearDataObjInp,
  953         (funcPtr)CALL_DATAOBJINP_GENQUERYOUT
  954     },
  955     {
  956         MOD_COLL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  957         "CollInpNew_PI", 0, NULL, 0,
  958         boost::any(std::function<int(rsComm_t*,collInp_t*)>(RS_MOD_COLL)),
  959         "api_mod_coll", clearCollInp,
  960         (funcPtr)CALL_COLLINP
  961     },
  962     {
  963         SUB_STRUCT_FILE_MKDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  964         REMOTE_PRIV_USER_AUTH, "SubFile_PI", 0, NULL, 0,
  965         boost::any(std::function<int(rsComm_t*,subFile_t*)>(RS_SUB_STRUCT_FILE_MKDIR)),
  966         "api_sub_struct_file_mkdir", irods::clearInStruct_noop,
  967         (funcPtr)CALL_SUBFILEINP
  968     },
  969     {
  970         SUB_STRUCT_FILE_RMDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  971         REMOTE_PRIV_USER_AUTH, "SubFile_PI", 0, NULL, 0,
  972         boost::any(std::function<int(rsComm_t*,subFile_t*)>(RS_SUB_STRUCT_FILE_RMDIR)),
  973         "api_sub_struct_file_rmdir", irods::clearInStruct_noop,
  974         (funcPtr)CALL_SUBFILEINP
  975     },
  976     {
  977         SUB_STRUCT_FILE_OPENDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  978         REMOTE_PRIV_USER_AUTH, "SubFile_PI", 0, NULL, 0,
  979         boost::any(std::function<int(rsComm_t*,subFile_t*)>(RS_SUB_STRUCT_FILE_OPENDIR)),
  980         "api_sub_struct_file_opendir", irods::clearInStruct_noop,
  981         (funcPtr)CALL_SUBFILEINP
  982     },
  983     {
  984         SUB_STRUCT_FILE_READDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  985         REMOTE_PRIV_USER_AUTH, "SubStructFileFdOpr_PI", 0, "RODS_DIRENT_T_PI", 0,
  986         boost::any(std::function<int(rsComm_t*,subStructFileFdOprInp_t*,rodsDirent_t**)>(RS_SUB_STRUCT_FILE_READDIR)),
  987         "api_sub_struct_file_readdir", irods::clearInStruct_noop,
  988         (funcPtr)CALL_SUBSTRUCTFILEFDOPRINP_RODSDIRENTOUT
  989     },
  990     {
  991         SUB_STRUCT_FILE_CLOSEDIR_AN, RODS_API_VERSION, REMOTE_USER_AUTH,
  992         REMOTE_PRIV_USER_AUTH, "SubStructFileFdOpr_PI", 0, NULL, 0,
  993         boost::any(std::function<int(rsComm_t*,subStructFileFdOprInp_t*)>(RS_SUB_STRUCT_FILE_CLOSEDIR)),
  994         "api_sub_struct_file_closedir", irods::clearInStruct_noop,
  995         (funcPtr)CALL_SUBSTRUCTFILEFDOPRINP
  996     },
  997     {
  998         DATA_OBJ_TRUNCATE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
  999         "DataObjInp_PI", 0, NULL, 0,
 1000         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_DATA_OBJ_TRUNCATE)),
 1001         "api_data_obj_truncate", clearDataObjInp,
 1002         (funcPtr)CALL_DATAOBJINP
 1003     },
 1004     {
 1005         SUB_STRUCT_FILE_TRUNCATE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
 1006         "SubFile_PI", 0, NULL, 0,
 1007         boost::any(std::function<int(rsComm_t*,subFile_t*)>(RS_SUB_STRUCT_FILE_TRUNCATE)),
 1008         "api_sub_struct_file_truncate", irods::clearInStruct_noop,
 1009         (funcPtr)CALL_SUBFILEINP
 1010     },
 1011     {
 1012         GET_XMSG_TICKET_AN, RODS_API_VERSION, REMOTE_USER_AUTH | XMSG_SVR_ONLY, REMOTE_USER_AUTH | XMSG_SVR_ONLY,
 1013         "GetXmsgTicketInp_PI", 0, "XmsgTicketInfo_PI", 0,
 1014         boost::any(std::function<int(rsComm_t*,getXmsgTicketInp_t*,xmsgTicketInfo_t**)>(RS_GET_XMSG_TICKET)),
 1015         "api_get_xmsg_ticket", irods::clearInStruct_noop,
 1016         (funcPtr)CALL_GETXMSGTICKETINP_XMSGTICKETINFOOUT
 1017     },
 1018     {
 1019         SEND_XMSG_AN, RODS_API_VERSION, XMSG_SVR_ONLY, XMSG_SVR_ONLY,
 1020         "SendXmsgInp_PI", 0, NULL, 0,
 1021         boost::any(std::function<int(rsComm_t*,sendXmsgInp_t*)>(RS_SEND_XMSG)),
 1022         "api_send_xmsg", irods::clearInStruct_noop,
 1023         (funcPtr)CALL_SENDXMSGINP
 1024     },
 1025     {
 1026         RCV_XMSG_AN, RODS_API_VERSION, XMSG_SVR_ONLY, XMSG_SVR_ONLY,
 1027         "RcvXmsgInp_PI", 0, "RcvXmsgOut_PI", 0,
 1028         boost::any(std::function<int(rsComm_t*,rcvXmsgInp_t*,rcvXmsgOut_t**)>(RS_RCV_XMSG)),
 1029         "api_rcv_xmsg", irods::clearInStruct_noop,
 1030         (funcPtr)CALL_RCVXMSGINP_RCVXMSGOUT
 1031     },
 1032     {
 1033         SUB_STRUCT_FILE_GET_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1034         "SubFile_PI", 0, NULL, 1,
 1035         boost::any(std::function<int(rsComm_t*,subFile_t*,bytesBuf_t*)>(RS_SUB_STRUCT_FILE_GET)),
 1036         "api_sub_struct_file_get", irods::clearInStruct_noop,
 1037         (funcPtr)CALL_SUBFILEINP_BYTESBUFOUT
 1038     },
 1039     {
 1040         SUB_STRUCT_FILE_PUT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1041         "SubFile_PI", 1, NULL, 0,
 1042         boost::any(std::function<int(rsComm_t*,subFile_t*,bytesBuf_t*)>(RS_SUB_STRUCT_FILE_PUT)),
 1043         "api_sub_struct_file_put", irods::clearInStruct_noop,
 1044         (funcPtr)CALL_SUBFILEINP_BYTESBUFOUT
 1045     },
 1046     {
 1047         SYNC_MOUNTED_COLL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1048         "DataObjInp_PI", 0, NULL, 0,
 1049         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_SYNC_MOUNTED_COLL)),
 1050         "api_sync_mounted_coll", clearDataObjInp,
 1051         (funcPtr)CALL_DATAOBJINP
 1052     },
 1053     {
 1054         STRUCT_FILE_SYNC_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1055         "StructFileOprInp_PI", 0, NULL, 0,
 1056         boost::any(std::function<int(rsComm_t*,structFileOprInp_t*)>(RS_STRUCT_FILE_SYNC)),
 1057         "api_struct_file_sync", irods::clearInStruct_noop,
 1058         (funcPtr)CALL_STRUCTFILEOPRINP
 1059     },
 1060     {
 1061         COLL_CREATE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1062         "CollInpNew_PI", 0, NULL, 0,
 1063         boost::any(std::function<int(rsComm_t*,collInp_t*)>(RS_COLL_CREATE)),
 1064         "api_coll_create", clearCollInp,
 1065         (funcPtr)CALL_COLLINP
 1066     },
 1067     {
 1068         STRUCT_FILE_EXTRACT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1069         "StructFileOprInp_PI", 0, NULL, 0,
 1070         boost::any(std::function<int(rsComm_t*,structFileOprInp_t*)>(RS_STRUCT_FILE_EXTRACT)),
 1071         "api_struct_file_extract", irods::clearInStruct_noop,
 1072         (funcPtr)CALL_STRUCTFILEOPRINP
 1073     },
 1074     {
 1075         STRUCT_FILE_EXT_AND_REG_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1076         "StructFileExtAndRegInp_PI", 0, NULL, 0,
 1077         boost::any(std::function<int(rsComm_t*,structFileExtAndRegInp_t*)>(RS_STRUCT_FILE_EXT_AND_REG)),
 1078         "api_struct_file_ext_and_reg", irods::clearInStruct_noop,
 1079         (funcPtr)CALL_STRUCTFILEEXTANDREGINP
 1080     },
 1081     {
 1082         STRUCT_FILE_BUNDLE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1083         "StructFileExtAndRegInp_PI", 0, NULL, 0,
 1084         boost::any(std::function<int(rsComm_t*,structFileExtAndRegInp_t*)>(RS_STRUCT_FILE_BUNDLE)),
 1085         "api_struct_file_bundle", irods::clearInStruct_noop,
 1086         (funcPtr)CALL_STRUCTFILEEXTANDREGINP
 1087     },
 1088     {
 1089         CHK_OBJ_PERM_AND_STAT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1090         "ChkObjPermAndStat_PI", 0, NULL, 0,
 1091         boost::any(std::function<int(rsComm_t*,chkObjPermAndStat_t*)>(RS_CHK_OBJ_PERM_AND_STAT)),
 1092         "api_chk_obj_perm_and_stat", irods::clearInStruct_noop,
 1093         (funcPtr)CALL_CHKOBJPERMANDSTATINP
 1094     },
 1095     {
 1096         GET_REMOTE_ZONE_RESC_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1097         "DataObjInp_PI", 0, "RHostAddr_PI", 0,
 1098         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,rodsHostAddr_t**)>(RS_GET_REMOTE_ZONE_RESC)),
 1099         "api_get_remote_zone_resc", clearDataObjInp,
 1100         (funcPtr) CALL_DATAOBJINP_RODSHOSTADDROUT
 1101     },
 1102     {
 1103         DATA_OBJ_OPEN_AND_STAT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1104         "DataObjInp_PI", 0, "OpenStat_PI", 0,
 1105         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,openStat_t**)>(RS_DATA_OBJ_OPEN_AND_STAT)),
 1106         "api_data_obj_open_and_stat", clearDataObjInp,
 1107         (funcPtr)CALL_DATAOBJINP_OPENSTATOUT
 1108     },
 1109     {
 1110         L3_FILE_GET_SINGLE_BUF_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1111         "INT_PI", 0, NULL, 1,
 1112         boost::any(std::function<int(rsComm_t*,int*,bytesBuf_t*)>(RS_L3_FILE_GET_SINGLE_BUF)),
 1113         "api_l3_file_get_single_buf", irods::clearInStruct_noop,
 1114         (funcPtr)CALL_INTINP_BYTESBUFOUT
 1115     },
 1116     {
 1117         L3_FILE_PUT_SINGLE_BUF_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1118         "INT_PI", 1, NULL, 0,
 1119         boost::any(std::function<int(rsComm_t*,int*,bytesBuf_t*)>(RS_L3_FILE_PUT_SINGLE_BUF)),
 1120         "api_l3_file_put_single_buf", irods::clearInStruct_noop,
 1121         (funcPtr)CALL_INTINP_BYTESBUFOUT
 1122     },
 1123     {
 1124         DATA_OBJ_CREATE_AND_STAT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1125         "DataObjInp_PI", 0, "OpenStat_PI", 0,
 1126         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,openStat_t**)>(RS_DATA_OBJ_CREATE_AND_STAT)),
 1127         "api_data_obj_create_and_stat", clearDataObjInp,
 1128         (funcPtr)CALL_DATAOBJINP_OPENSTATOUT
 1129     },
 1130     {
 1131         PHY_BUNDLE_COLL_AN, RODS_API_VERSION, LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
 1132         "StructFileExtAndRegInp_PI", 0, NULL, 0,
 1133         boost::any(std::function<int(rsComm_t*,structFileExtAndRegInp_t*)>(RS_PHY_BUNDLE_COLL)),
 1134         "api_phy_bundle_coll", irods::clearInStruct_noop,
 1135         (funcPtr)CALL_STRUCTFILEEXTANDREGINP
 1136     },
 1137     {
 1138         UNBUN_AND_REG_PHY_BUNFILE_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
 1139         "DataObjInp_PI", 0, NULL, 0,
 1140         boost::any(std::function<int(rsComm_t*,dataObjInp_t*)>(RS_UNBUN_AND_REG_PHY_BUNFILE)),
 1141         "api_unbun_and_reg_phy_bunfile", clearDataObjInp,
 1142         (funcPtr)CALL_DATAOBJINP
 1143     },
 1144     {
 1145         GET_HOST_FOR_PUT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1146         "DataObjInp_PI", 0, "STR_PI", 0,
 1147         boost::any(std::function<int(rsComm_t*,dataObjInp_t*,char**)>(RS_GET_HOST_FOR_PUT)),
 1148         "api_get_host_for_put", clearDataObjInp,
 1149         (funcPtr)CALL_DATAOBJINP_CHAROUT
 1150     },
 1151     {
 1152         GET_RESC_QUOTA_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1153         "getRescQuotaInp_PI", 0, "rescQuota_PI", 0,
 1154         boost::any(std::function<int(rsComm_t*,getRescQuotaInp_t*,rescQuota_t**)>(RS_GET_RESC_QUOTA)),
 1155         "api_get_resc_quota", irods::clearInStruct_noop,
 1156         (funcPtr)CALL_GETRESCQUOTAINP_RESCQUOTAOUT
 1157     },
 1158     {
 1159         BULK_DATA_OBJ_REG_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1160         "GenQueryOut_PI", 0, "GenQueryOut_PI", 0,
 1161         boost::any(std::function<int(rsComm_t*,genQueryOut_t*,genQueryOut_t**)>(RS_BULK_DATA_OBJ_REG)),
 1162         "api_bulk_data_obj_reg", clearGenQueryOut,
 1163         (funcPtr)CALL_GENQUERYOUTINP_GENQUERYOUT
 1164     },
 1165     {
 1166         BULK_DATA_OBJ_PUT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1167         "BulkOprInp_PI", 1, NULL, 0,
 1168         boost::any(std::function<int(rsComm_t*,bulkOprInp_t*,bytesBuf_t*)>(RS_BULK_DATA_OBJ_PUT)),
 1169         "api_bulk_data_obj_put", clearBulkOprInp,
 1170         (funcPtr)CALL_BULKOPRINP_BYTESBUFOUT
 1171     },
 1172     {
 1173         PROC_STAT_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1174         "ProcStatInp_PI", 0, "GenQueryOut_PI", 0,
 1175         boost::any(std::function<int(rsComm_t*,procStatInp_t*,genQueryOut_t**)>(RS_PROC_STAT)),
 1176         "api_proc_stat", irods::clearInStruct_noop,
 1177         (funcPtr)CALL_PROCSTATINP_GENQUERYOUT
 1178     },
 1179     {
 1180         STREAM_READ_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1181         "fileReadInp_PI", 0, NULL, 1,
 1182         boost::any(std::function<int(rsComm_t*,fileReadInp_t*,bytesBuf_t*)>(RS_STREAM_READ)),
 1183         "api_stream_read", irods::clearInStruct_noop,
 1184         (funcPtr)CALL_FILEREADINP_BYTESBUFOUT
 1185     },
 1186     {
 1187         REG_COLL_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1188         "CollInpNew_PI", 0, NULL, 0,
 1189         boost::any(std::function<int(rsComm_t*,collInp_t*)>(RS_REG_COLL)),
 1190         "api_reg_coll", clearCollInp,
 1191         (funcPtr)CALL_COLLINP
 1192     },
 1193     {
 1194         REG_DATA_OBJ_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1195         "DataObjInfo_PI", 0, "DataObjInfo_PI", 0,
 1196         boost::any(std::function<int(rsComm_t*,dataObjInfo_t*,dataObjInfo_t**)>(RS_REG_DATA_OBJ)),
 1197         "api_reg_data_obj", irods::clearInStruct_noop,
 1198         (funcPtr)CALL_DATAOBJINFOINP_DATAOBJINFOOUT
 1199     },
 1200     {
 1201         UNREG_DATA_OBJ_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1202         "UnregDataObj_PI", 0, NULL, 0,
 1203         boost::any(std::function<int(rsComm_t*,unregDataObj_t*)>(RS_UNREG_DATA_OBJ)),
 1204         "api_unreg_data_obj", clearUnregDataObj,
 1205         (funcPtr)CALL_UNREGDATAOBJINP
 1206     },
 1207     {
 1208         REG_REPLICA_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_PRIV_USER_AUTH,
 1209         "RegReplica_PI", 0, NULL, 0,
 1210         boost::any(std::function<int(rsComm_t*,regReplica_t*)>(RS_REG_REPLICA)),
 1211         "api_reg_replica", clearRegReplicaInp,
 1212         (funcPtr)CALL_REGREPLICAINP
 1213     },
 1214     {
 1215         FILE_CHKSUM_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1216         "fileChksumInp_PI", 0, "fileChksumOut_PI", 0,
 1217         boost::any(std::function<int(rsComm_t*,fileChksumInp_t*,char**)>(RS_FILE_CHKSUM)),
 1218         "api_file_chksum", irods::clearInStruct_noop,
 1219         (funcPtr)CALL_FILECHKSUMINP_CHAROUT
 1220     },
 1221     {
 1222         SSL_START_AN, RODS_API_VERSION,
 1223         NO_USER_AUTH | XMSG_SVR_ALSO, NO_USER_AUTH | XMSG_SVR_ALSO,
 1224         "sslStartInp_PI", 0, NULL, 0,
 1225         boost::any(std::function<int(rsComm_t*,sslStartInp_t*)>(RS_SSL_START)),
 1226         "api_ssl_start", irods::clearInStruct_noop,
 1227         (funcPtr)CALL_SSLSTARTINP
 1228     },
 1229     {
 1230         SSL_END_AN, RODS_API_VERSION,
 1231         NO_USER_AUTH | XMSG_SVR_ALSO, NO_USER_AUTH | XMSG_SVR_ALSO,
 1232         "sslEndInp_PI", 0, NULL, 0,
 1233         boost::any(std::function<int(rsComm_t*,sslEndInp_t*)>(RS_SSL_END)),
 1234         "api_ssl_end", irods::clearInStruct_noop,
 1235         (funcPtr)CALL_SSLENDINP
 1236     },
 1237     {
 1238         AUTH_PLUG_REQ_AN, RODS_API_VERSION, NO_USER_AUTH, NO_USER_AUTH,
 1239         "authPlugReqInp_PI", 0, "authPlugReqOut_PI", 0,
 1240         boost::any(std::function<int(rsComm_t*,authPluginReqInp_t*,authPluginReqOut_t**)>(RS_AUTH_PLUG_REQ)),
 1241         "api_auth_plugin_request", irods::clearInStruct_noop,
 1242         (funcPtr)CALL_AUTHPLUGINREQINP_AUTHPLUGINREQOUT
 1243     },
 1244     {
 1245         GET_HIER_FOR_RESC_AN, RODS_API_VERSION, NO_USER_AUTH, NO_USER_AUTH,
 1246         "getHierarchyForRescInp_PI", 0, "getHierarchyForRescOut_PI", 0,
 1247         boost::any(std::function<int(rsComm_t*,getHierarchyForRescInp_t*,getHierarchyForRescOut_t**)>(RS_GET_HIER_FOR_RESC)),
 1248         "api_get_hierarchy_for_resc", irods::clearInStruct_noop,
 1249         (funcPtr)CALL_GETHIERARCHYFORRESCINP_GETHIERARCHYFORRESCOUT
 1250     },
 1251     {
 1252         ZONE_REPORT_AN, RODS_API_VERSION, LOCAL_PRIV_USER_AUTH, LOCAL_PRIV_USER_AUTH,
 1253         NULL, 0,  "BytesBuf_PI", 0,
 1254         boost::any(std::function<int(rsComm_t*,bytesBuf_t**)>(RS_ZONE_REPORT)),
 1255         "api_zone_report", irods::clearInStruct_noop,
 1256         (funcPtr)CALL_BYTESBUFOUT
 1257     },
 1258     {
 1259         SERVER_REPORT_AN, RODS_API_VERSION, REMOTE_PRIV_USER_AUTH, REMOTE_PRIV_USER_AUTH,
 1260         NULL, 0,  "BytesBuf_PI", 0,
 1261         boost::any(std::function<int(rsComm_t*,bytesBuf_t**)>(RS_SERVER_REPORT)),
 1262         "api_server_report", irods::clearInStruct_noop,
 1263         (funcPtr)CALL_BYTESBUFOUT
 1264     },
 1265     {
 1266         CLIENT_HINTS_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1267         NULL, 0,  "BytesBuf_PI", 0,
 1268         boost::any(std::function<int(rsComm_t*,bytesBuf_t**)>(RS_CLIENT_HINTS)),
 1269         "api_client_hints", irods::clearInStruct_noop,
 1270         (funcPtr)CALL_BYTESBUFOUT
 1271     },
 1272     {
 1273         IES_CLIENT_HINTS_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1274         NULL, 0,  "BytesBuf_PI", 0,
 1275         boost::any(std::function<int(rsComm_t*,bytesBuf_t**)>(RS_IES_CLIENT_HINTS)),
 1276         "api_ies_client_hints", irods::clearInStruct_noop,
 1277         (funcPtr)CALL_BYTESBUFOUT
 1278     },
 1279     {
 1280         GET_HIER_FROM_LEAF_ID_AN, RODS_API_VERSION, REMOTE_USER_AUTH, REMOTE_USER_AUTH,
 1281         "GetHierInp_PI", 0,  "GetHierOut_PI", 0,
 1282         boost::any(std::function<int(rsComm_t*,get_hier_inp_t*,get_hier_out_t**)>(RS_GET_HIER_FROM_LEAF_ID)),
 1283         "api_get_hier_from_leaf_id", irods::clearInStruct_noop,
 1284         (funcPtr)CALL_GETHIERINP_GETHIEROUT
 1285     },
 1286     {
 1287         SET_RR_CTX_AN, RODS_API_VERSION, LOCAL_USER_AUTH, LOCAL_USER_AUTH,
 1288         "SetRoundRobinContextInp_PI", 0,  NULL, 0,
 1289         boost::any(std::function<int(rsComm_t*,setRoundRobinContextInp_t*)>(RS_SET_ROUNDROBIN_CONTEXT)),
 1290         "api_set_round_robin_context", irods::clearInStruct_noop,
 1291         (funcPtr)CALL_SETROUNDROBINCONTEXTINP
 1292     },
 1293     {
 1294         EXEC_RULE_EXPRESSION_AN, RODS_API_VERSION, LOCAL_USER_AUTH, LOCAL_USER_AUTH,
 1295         "ExecRuleExpression_PI", 0,  NULL, 0,
 1296         boost::any(std::function<int(rsComm_t*,exec_rule_expression_t*)>(RS_EXEC_RULE_EXPRESSION)),
 1297         "api_exec_rule_expression", irods::clearInStruct_noop,
 1298         (funcPtr)CALL_EXECRULEEXPRESSIONINP
 1299     },
 1300 }; // _api_table_inp
 1301 
 1302 #endif  /* API_TABLE_H */