tripapi.h

 
#ifndef __TRIPAPI_PROTOTYPES__
#define __TRIPAPI_PROTOTYPES__
 
#include <stdio.h>
#include <time.h>
 
/* Macros for compiler-specific deprecation signaling */
#ifdef __cplusplus
#if __cplusplus >= 201300
#define TDB_DEPRECATED(msg) [[deprecated(msg)]]
#endif
#endif
#ifndef TDB_DEPRECATED
#ifdef _MSC_VER
#define TDB_DEPRECATED(msg) __declspec(deprecated(msg))
#elif defined(__GNUC__) || defined(__clang__)
#define TDB_DEPRECATED(msg) __attribute__((deprecated))
#else
#define TDB_DEPRECATED(msg)
#endif
#endif
 
/* Include the kernel structure and constant definitions required */
#include "tripapi_defs.h"
#include "tripapi_types.h"
 
#if defined(__cplusplus)
extern "C" {
#endif

 

   int TdbApiLogEnable(boolean enable);

   int TdbApiLogCheckpoint(int id);

   int TdbApiLogRead(int checkpoint_id, long* position, char* buffer,
                     size_t bufsize, size_t* readcount);

   int TdbApiLogSetVerbosity(int level);
   
   int TdbCheckDate(int dateform, char* datestring, int* dateint);
 
   
   int TdbCheckUser(const char* user, const char* password, char* FM, char* UM, char* SM);

   int TdbChangeUser(const char* user, const char* password, int mode);

   int TdbSetUICharset(int charset);

   int TdbCreateTicket(char* ticket, int maxlen);

   int TdbDeleteTicket(const char* ticket);
   

    int TdbCreateTokenPair(const char* apikey,
        const char* user, const char* tag,
        char** access_token, int* access_token_length,
        char** refresh_token, int* refresh_token_length,
        time_t* access_expires_at, time_t* refresh_expires_at);

    int TdbRefreshTokenPair(const char* apikey,
        const char* current_refresh_token,
        char** access_token, int* access_token_length,
        char** refresh_token, int* refresh_token_length,
        time_t* access_expires_at, time_t* refresh_expires_at,
        char* username, size_t username_size);

    int TdbPurgeUserTokens(int mode, const char* username, 
        time_t from_fimestamp, time_t to_timestamp, int* purgedcount,
        FP_TdbPurgeTokensCallback callback, void* userdata);

    int TdbPurgeTokens(int mode, 
        time_t from_timestamp, time_t to_timestamp, int* purgedcount,
        FP_TdbPurgeTokensCallback callback, void* userdata);

    int TdbRevokeTokens(const char* username, const char* token, const char* tag,
        int* revokecount, FP_TdbPurgeTokensCallback callback, void* userdata);

    int TdbEnumUserTokens(const char* username, void** handle, 
        char* tag, size_t tag_size,
        time_t* created, time_t* access_expires_at, 
        time_t* refresh_expires_at);

    int TdbEnumTokens(void** handle,  char* user, size_t user_size, 
        char* tag, size_t tag_size, time_t* created,
        time_t* access_expires_at, time_t* refresh_expires_at);

    int TdbCreateApiKey(const char* keyname, const char* comment,
        boolean replace, char** keybuf, int* keybuf_size);

    int TdbRevokeApiKey(const char* keyname);

    int TdbApiKeyInfo(const char* keyname, int mode, 
        char* outstr, size_t outstrsz, int* outint);

    int TdbCheckApiKey(const char* apikey);

    int TdbEnumApiKeys(void** handle, 
        char* keyname, size_t keyname_size,
        char* comment, size_t comment_size,
        char* creator, size_t creator_size,
        char* credate, size_t credate_size,
        char* cretime, size_t cretime_size);

   int TdbMessage(int messageNumber, char* message, int* length);
 
   
   int TdbRetCode(void);
 

   int TdbIsSuperUser(void);
 

   int TdbShellDefDateform(int dateform, char* datestring);
 
   
   int TdbShellModifyCcl(int language);
 
   
   int TdbShellType(char* fieldtypeName, int* fieldtypeNumber);
 
   
   int TdbStartTrip(char* username, char* password, int language, int mode);
   
   
   
   int TdbStopTrip(boolean restart);

   int TdbGetConf(const char* symbolName, int section, 
       char* valueBuffer, size_t bufferSize,
       const char* defaultValue);

   int TdbSetConf(const char* symbolName, const char* symbolValue);
 

   int TdbResolvePath(const char* symbolPath, char* resolved, size_t bufsize);
 
   
   // ------------------------------------------------------------------------

 
   

   int TdbBatchLoadIndex(int mode, const char* base, const char* tformFile);

   int TdbSubmitBatchJob(int* jobid, int jobtype, const char* base, const char* tform);
   
   int TdbIndex(const char* base, int recordNumber);
   
         // END OF BATCH COMMANDS BLOCK

 

   int TdbCheckCcl(char* cclorder, int* status);
   

   int TdbExecuteCcl(char* cclorder, int* status);
 
   
   int TdbDidYouMean(char* buffer, int* length);
   

   int TdbGetParsedCcl(int mode, char** parsed_order, int* length);
 
   
        // END OF CCL COMMANDS BLOCK
   
   
 

   int TdbCheckSearch(int* search);
   

   int TdbSearchInfo(int search_number, int mode, int64_t* integer_value,
                     char* string_buffer, size_t string_buffer_size);
   
         // END OF SEARCH SETS BLOCK
   

   int TdbCurrentBase(char* base);
 
   
   
   int TdbCreateTermSet(int* termsetId);
   
   int TdbDeleteTermSet(int termsetId);

   int TdbCreateBaselineTermSet(int *termsetId, const char *shin, int mode);

   int TdbUpdateTermSet(int termsetId, const char *shin, int mode);
 

   int TdbTermSetCount(int termsetId, int64_t* recordCount, int64_t* updateCount);
   
   
   int TdbGetDisplay(int* termCount, int* termType);
 
   
   int TdbGetDisplayTerm(int termNumber, char* term, int* termLength,
                         int* recordCount);
 
   
   int TdbGetDisplayTermEx(int termNumber, char* term, int* termLength,
                           int64_t* recordCount);
 
   
   int TdbGetTermSetTerm(int termsetId, int termNumber, char* termValue,
                         int* length, int* recordCount);
 

   int TdbGetTermSetTermEx(int termsetId, int termNumber, char* termValue,
                           int* length, int64_t* recordCount,
                           int64_t* updateCount);
   
   
 
   
   // ------------------------------------------------------------------------

   
   
   int TdbCheckScreenWindow(int windowType, int* windowId);
 
   
   int TdbDefineWindow(int windowType, int height, int width);
 
   
   int TdbDeleteWindow(int windowNumber);
 
   
   int TdbGetWindowHit(int windowType, int* linePosition, int* length);
 
   

   int TdbGetWindowHits(int windowType, int* hitCount, int** windowHits);
   

   int TdbGetWindowInfo(int windowType, char** windowBuffer, int* rowSize,
                        int* colSize, int* rowCount, int* flags);
 
   
   int TdbGetWindowLine(int windowType, char* line);
 
   
   int TdbGetWindowType(int windowId, int* windowType);
 
   
   int TdbSetScreenWindow(int windowType, int windowNumber);
 
   
   // ------------------------------------------------------------------------

   

   int TdbClearRunStack(void);
 
   
   int TdbContinue(void);
 
   

   int TdbCopyProcedure(char* oldProcedure, char* newProcedure);
 
   
   int TdbDeleteProcedure(char* procedure);
 
   
   int TdbGetNextProcLine(char** line, int* length);
 
   

   int TdbGetProcLine(char* line, int* lineLength);
 
   

   int TdbGetProcedure(char* procedure);
 
   

   int TdbPutProcLine(char* line, int lineLength);
   

   int TdbPutProcedure(void);
 
   
   // ------------------------------------------------------------------------
   
 

    int TdbAddMember(const char* group, const char* user);
 

    int TdbChangeFm(const char* old_fm, const char* new_fm, const char* base);
 
   
    int TdbChangePassword(const char* oldpass, const char* newpass);
 

    int TdbChangeUm(const char* old_um, const char* new_um, const char* user_group);
 

   int TdbCheckMember(const char* group, const char* user);
   

   int TdbCreateGroup(const char* group);
   
   
    int TdbCreateUser(const char* username, const char* password);
    
    
   int TdbDeleteGroup(const char* group);
 

   int TdbDeleteMember(const char* group, const char* user);
 
   

   int TdbDeleteUser(const char* user);
 

   int TdbGetGroup(char* group, int* memberCount);
 
   
   int TdbGetGroupName(char* groupName, int gid);
 
   
   int TdbGetMembers(char* members, int* length);
   
   
   int TdbGetUserProfile(char* user, user_profile_rec* profile);
 
   
   int TdbGetUserRights(const char* user, boolean* UM, boolean* FM);
 
   
   int TdbPutUserProfile(user_profile_rec* profileRecord);
   
   
   int TdbPutUserRights(boolean UM, boolean FM);
 
   
   int TdbOsUser(char* OSuser, int* length);
 
   
   int TdbSetPassword(const char* user, const char* password);
 
   
   int TdbSystemMode(const char* password);
 

   int TdbTdbsUser(char* userName, int* length);
 
   
   // ------------------------------------------------------------------------

 
   
 
   
   int TdbBaseInfo(const char* base, int mode, char* cvalue, int* ivalue);
 

   int TdbClusterInfo(int mode, const char* cluster, char* outstr, size_t outstrsz, int64_t* outint);
   
   
   int TdbBaseStatus(const char* base, char* revisionDate, char* indexDate,
                     int* recordCount);
   
 
        // END OF GENERAL DB FUNCTIONS BLOCK
   
   

   int TdbCheckBase(const char* base, int accessMode);
 
   
   int TdbCheckDbCluster(const char* clusterName, int accessMode);
 
   
   int TdbCheckThes(const char* thesaurus, int accessMode);
    
    
   int TdbGetDbAccess(char* user, base_access_rec* baseAccess);
 
   
   int TdbPutDbAccess(base_access_rec* baseAccess);
 
   
        // END OF DB ACCESS FUNCTIONS BLOCK
   
   

   int TdbCheckFieldName(const char* field_name);
 
   
   int TdbCopyBaseDesign(const char* from_base, const char* to_base,
                         TdbHandle* design);
   
   
   int TdbDeleteBaseDef();
   

   int TdbPutBaseDesign(TdbHandle handle);

   int TdbGetTextSeparators(text_sepa_rec* separatorSpec);
   

   int TdbPutTextSeparators(text_sepa_rec* separatorSpec);
 
   
   int TdbGetBaseDesign(TdbHandle* handle, const char* base, int accessMode);
   

   int TdbCloseBaseDesign(TdbHandle* handle);
   

   int TdbGetBaseProperty(TdbHandle handle, int property_id, int* numeric_value,
                          char* string_value_buffer, int string_buffer_size);
   
   int TdbPutBaseProperty(TdbHandle handle,int property_id, int numeric_value,
                          const char* string_value);
   
   
        // END OF DB DESIGN FUNCTIONS BLOCK
   
   
   
   int TdbGetBaseField(TdbHandle* fieldHandle, TdbHandle  baseHandle,
                       const char* fieldName, int ordinal);
 
 

   int TdbGetBaseFieldByNumber(TdbHandle* fieldHandle, TdbHandle  baseHandle,
      int fieldNumber);

   int TdbDeleteBaseField(TdbHandle* fieldHandle);
 
   
   int TdbPutBaseField(TdbHandle handle);
   
   
   int TdbCloseBaseField(TdbHandle* handle);
   
   int TdbGetFieldProperty(TdbHandle handle, int property_id,
                           int* numeric_value, char* string_value_buffer,
                           int string_buffer_size);
   
   int
   TdbPutFieldProperty(TdbHandle field_design_handle,int property_id,
                       int numeric_value, const char* string_value);
 
   
     // END OF DB FIELD FUNCTIONS BLOCK
   
   
   int
   TdbGetBaseFieldGroup(TdbHandle* fgrp_design_handle,
                        TdbHandle base_design_handle,
                        const char* name, int ordinal);
   
   int TdbPutBaseFieldGroup(TdbHandle handle);
   
   
   int TdbCloseBaseFieldGroup(TdbHandle* handle);
   
   int TdbDeleteBaseFieldGroup(TdbHandle* handle);
   
   int
   TdbGetFieldGroupProperty(TdbHandle handle, int property_id,
                            int* numeric_value,
                            char* string_value_buffer, int string_buffer_size);
   
   int
   TdbPutFieldGroupProperty(TdbHandle handle, int property_id,
                            int numeric_value, const char* string_value);
   
   int
   TdbFieldGroupAddField(TdbHandle handle, const char* field_name);
      
   int TdbFieldGroupDelField(TdbHandle handle, const char* field_name);
   
   int
   TdbFieldGroupGetField(TdbHandle field_group_handle,
                         TdbHandle* field_handle,
                         const char* field_name,
                         int ordinal);
        // END OF DB FIELD GROUP FUNCTIONS BLOCK
 


   int TdbGetIntegrityRules(base_integrity_spec** rules);
   
   int TdbFreeIntegrityRules(base_integrity_spec* rules);
   
   int TdbDeleteIntegrityRules();
   
   int TdbCheckForeignKey(Char* keyfield, Char* parentdb, Char* parentfld);
   
   int TdbSetForeignKey(Char* keyfield, Char* parentdb, Char* parentfld, int upd, int del);
   
   int TdbDeleteForeignKey(Char* keyfield);
   
   int TdbGetDefaultValue(Char* fieldName, Char* fieldValue,
                          int* fieldLength);
   
   int TdbPutDefaultValue(Char* fieldName, Char* fieldValue);
   
   int TdbDeleteDefaultValue(Char* fieldName);
   
        // END OF REFERERENTIAL INTEGRITY FUNCTIONS BLOCK
 
   

   int TdbCopyThesDesign(const char* from_thes, const char* to_thes,
                         TdbHandle* design);
 
   
   int TdbDeleteThesDef(void);

   int TdbGetThesDesign(TdbHandle* handle, const char* name, int accessMode);
   
   int TdbPutThesDesign(TdbHandle handle);
        // END OF THES DESIGN FUNCTIONS BLOCK
 
    

   int TdbDeleteDbCluster(void);
   

   int TdbGetClusterDesign(TdbHandle* cluster_handle,
                           const char* cluster_name,
                           int access_mode);
   
   
   int TdbPutClusterDesign(TdbHandle handle);
   
   
   int TdbCloseClusterDesign(TdbHandle* handle);
 
   
   int TdbCopyClusterDesign(TdbHandle sourceHandle, const char* newName,
                        TdbHandle* targetHandle);
   
   int TdbClusterAddMember(TdbHandle handle, const char* name);
   
   
   int TdbClusterDelMember(TdbHandle handle, int position, const char* name);
 
   
   int TdbClusterDelMembers(TdbHandle handle);

   int TdbClusterEnumMembers(TdbHandle handle, int* position,
                             char* name, int namesize);
 
   
   int TdbClusterGetMember(TdbHandle handle, int position,
                           char* name, int namesize);
   
   int TdbGetClusterProperty(TdbHandle handle, int property_id,
                             int* numeric_value, char* string_value_buffer,
                             int string_buffer_size);
   
   
   int TdbPutClusterProperty(TdbHandle handle, int property_id,
                             int numeric_value, const char* string_value);
        // END OF CLUSTER FUNCTIONS BLOCK
 
   
   
   
   // ------------------------------------------------------------------------
   

   int TdbCheckOutputFormat(void);
   
   
   int TdbCurrentForm(char* base, char* form, int mode);
 
   
   int TdbCopyOutputFormat(char* old_base, char* old_form, char* new_base,
                           char* new_form, int* error);
   

   int TdbDeleteOutputFormat(char* base, char* format);
 
   
   int TdbGetComment(char* comment);
 
   
   int TdbGetFormLine(char* line, int* lineLength);
   
   
   int TdbGetOutputFormat(char* base, char* format);
 
   
   int TdbPutComment(char* comment);
 
   
   int TdbPutFormLine(char* line, int lineLength);
 
   
   int TdbPutOutputFormat(void);
 
 
   // ------------------------------------------------------------------------

   

   int TdbAppendRecordPart(TdbHandle cursor, const char* partName);
   

   int TdbCheckCursor(TdbHandle cursor, TdbHandle* recordControl,
                      int* field, int* paragraph, int* item);
   

   int TdbCheckData(TdbHandle recordControl, int field, int item, char *data,
                    int length);
 
   
   int TdbCheckExistence(TdbHandle recordControl, int field, char *data,
                         int length);
   

   int TdbCheckField(TdbHandle recordControl, char* name, int* number,
                     int* type, int* flags);
 

   int TdbCheckPartName(TdbHandle recordControl, int* partID, char* partName);
 

   int TdbCheckRecordName(TdbHandle recordControl, int* recordID, char* name);
 

   int TdbCheckSymbol(int* symClass, char* symbol, int* length);
 
 

   int TdbCreateRecordControl(TdbHandle* recordControl);
 

   int TdbCreateTimeStamp(unsigned int* tstamp, int type);
 
   
   int TdbCurrentItem(char* base, TdbHandle* recordControl, int* record,
                      int* part, int* field, int* paragraph, int* item);
 
   
   int TdbDeleteCursor(TdbHandle* cursor);
   
   
   int TdbDeleteItem(TdbHandle cursor);
 

   int TdbDeleteRecordControl(TdbHandle* recordControl);
 
   
   int TdbDeleteRecordInBase(TdbHandle recordControl);
 
   
   int TdbDeleteRecordPart(TdbHandle cursor, int mode);
 
   
   int TdbEraseRecordControl(TdbHandle recordControl);
 
   
   int TdbExportBlob(TdbHandle cursor, char* filename);
 

   int TdbGetBlobBlock(TdbHandle cursor, int blockNr, int blockSize,
                       char* block, int* blockLen);
 
   
   int TdbGetBlobSize(TdbHandle cursor, int* blobSize);
 

   int TdbGetHitPart(TdbHandle recordControl, int seqNumber, int* partNumber);
   

   int TdbGetItem(TdbHandle cursor, char* data_item, int* item_length);
 
   
   int TdbGetLine(TdbHandle cursor, char* line, int* line_length,
                  int maximum_length);
 
   
   int TdbGetLinkBase(char* base, char* recordNameField);
 
   
   int TdbGetLinkRecord(TdbHandle recordControl, char* record_name,
                        int length);
 

   int TdbGetNextHitWord(TdbHandle recordControl, int* part, int* field,
                         int* paragraph, int* item, int* word_position,
                         int* length);
   
   
   int TdbGetNextItem(TdbHandle cursor, char* data_item, int* length);
 

   int TdbGetRecord(TdbHandle recordControl, int mode, int search,
                    int64_t ordinal);
 
   
   int TdbGetRecordBuffer(TdbHandle cursor, char* buffer_address,
                          int buffer_length, int part_number,
                          int* filled_length);
 

   TDB_DEPRECATED("Deprecated by TdbGetRecord")
   int TdbGetRecordInBase(TdbHandle recordControl, int RID);
 

   TDB_DEPRECATED("Deprecated by TdbGetRecord")
   int TdbGetRecordInSearch(TdbHandle recordControl, int* search, int* RID,
                            char* base);
 
   
   TDB_DEPRECATED("Deprecated by TdbGetRecord")
   int TdbGetRecordInSearchRis(TdbHandle recordControl, int* search, int RIS,
                               int* RID, char* base);
   
   
   int TdbGetRecordInThes(TdbHandle recordControl, int termNumber, int* level);
 
   
   TDB_DEPRECATED("Deprecated by TdbGetRecord")
   int TdbGetSortedRecord(int search_no, TdbHandle rec_ctl, int ris,
                          int* rid, char* base);
   

   int TdbGetTimeStamp(TdbHandle recordControl, unsigned int* timestamp,
                       int type);
   
   
   int TdbHitParts(TdbHandle recordControl, int* parthits, int* partcount,
                   int* partmax);
   
   
   int TdbImportBlob(TdbHandle cursor, const char* filename);
 
 
   int TdbInsertItem(TdbHandle cursor, char* data_item, int item_length);
 
 
   
   int TdbInsertRecordPart(TdbHandle cursor, const char* partname);
 

   int TdbItemCount(TdbHandle cursor, int* count);
 
   
   int TdbLockRecord(TdbHandle recordControl);
 
   
   int TdbNextControl(TdbHandle* recordControl);
 
   
   int TdbPutBlobBlock(TdbHandle cursor, int blockLen, char* block);
 
   
   int TdbPutLine(TdbHandle cursor, char* line, int line_length);
 

   int TdbParaCount(TdbHandle cursor, int* count);
   

   int TdbPartCount(TdbHandle cursor, int* count);
 

   int TdbPutRecord(TdbHandle recordControl, int* recordId);
   

   int TdbPutRecordBuffer(TdbHandle cursor, char* buffer_address,
                          int buffer_len, int* err_partnr, int* err_fieldnr,
                          int* err_itemnr);
 
   
   int TdbRecordInfo(TdbHandle recordControl, int mode, char* stringValue,
                     int* intValue);
 
   
   int TdbCursorInfo(TdbHandle cursor, int mode, char* stringValue,
                     int* intValue);
 
   
   int TdbReleaseRecord(TdbHandle recordControl);
 
   
   int TdbRenameRecordPart(TdbHandle cursor, const char* part_name);
 
   
   int TdbReplaceItem(TdbHandle cursor, char* data_item, int item_length);
 
   
   int TdbSetBase(TdbHandle recordControl, char* base, int access_mode);
 
   
   int TdbSetCursor(TdbHandle* cursor, TdbHandle recordControl, int field,
                    int paragraph, int item);
 

   int TdbSetLinkBase(TdbHandle recordControl, char* base_name,
                      TdbHandle* base_id);
   
   
   int TdbSetRecordPart(TdbHandle* cursor, TdbHandle recordControl,
                        int part_number);
 
   
   int TdbShowControl(int mode, int all_flag, char* name1, char* name2);
  
  
   int TdbSortTerms(int termSetNumber, int sortFlags);
 
   
   int TdbSortRecords(int searchNumber, char* sortSpecification);
 

   int TdbSortRecordsEx(int searchNumber, const char* sortSpecification, int mode);
 
   
   int TdbStartControl(char* name);
 
   
   int TdbUndeleteRecordPart(TdbHandle cursor);
 
   
   int TdbValidValues(int field_number, TdbHandle base_id, char* term);

    int TdbGetFieldInfo(TdbHandle cursor, int* buf_len, char** rec_buf,
                        int* hit_cnt, int** hit_vec, int* para_cnt);
   
   int TdbPutFieldInfo(TdbHandle cursor, int buf_len, char* rec_buf);
   

   int TdbStartSummarization(void** handle, int engine_id);
   
   int TdbAccumulateSummarization(void* handle, TdbHandle cursor);
   
   int TdbGenerateSummary(void* handle, Char** summary);
   
   int TdbEndSummarization(void* handle);
 
   
   
   
   // ------------------------------------------------------------------------

 

   int TdbBaffitMode(void);
   

   int TdbCurrentDate(char* date, int* length);
 
   
   int TdbCurrentTime(char* timestr, int* length);
 

   int TdbFieldInfo(TdbHandle cursor, int mode, char* cvalue, int* ivalue);
 
   
   int TdbGetQueuedMessage(char* message, int* length, char* logfile);
 

   int TdbGetBatchJobResult(int* jobid, int* status, char* msg, size_t msg_size, size_t* msg_len, char* logfile, size_t logfile_size);
 
   
   int TdbLanguage(char* language);
 

   int TdbLicenseInfo(int mode, const char* strarg,
      char* stringValue, size_t strvalsz, int* intValue);
 

   int TdbSessionInfo(int mode, char* stringValue, int* intValue);

   int TdbEnumViews(int64_t* enum_cursor, char* view_name, size_t name_size,
                    char** view_def, size_t* def_size);

   int TdbShellSymbol(char* symbol, int* symbol_length);
 
  
   int TdbUserInfo(int mode, char* stringValue, int* intValue);
 
   
   int TdbVersion(char* version, int* version_length);
 
   
   // ------------------------------------------------------------------------

 

   int TdbAseRetCode(void);
 

   int TdbBreak(void);
   
   
   int TdbCallAse(void* aseID, char* argstr, int* arglen);
 

   int TdbExport(FilterData* fd);
 
   
   int TdbImport(FilterData* fd);
 
   
   int TdbLoadAse(char* ase_name, void** ase_id);
 
   
   int TdbLoadStatus(int mode);
 

   int TdbSaveStatus(void);
 
   
   int TdbSetBreakChars(int mask, void(*routine)(void), int mode);
 

   int TdbSetBreakFlag(void);
 
   
   int TdbSetComforterInterval(int seconds, FP_fncomfortercb proc);
   
   
   int TdbStrNormalize(char* string, int* length, int mode);
 
 
   // ------------------------------------------------------------------------

 

   int TdbGraphFind(int* resultSet, int sourceSet, int edgeSet, int targetSet,
                    int exclusionSet, const char* condition);
 

   int TdbGraphResolve(int* resultSet, int mode, int edgeSet,
                       const char* database);
   

   int TdbGraphTransitive(int* resultSet, int maxDepth, boolean reverse,
                          boolean allEdges, int edgeSet, int sourceSet,
                          int targetSet, const char* condition);
   
   
   int TdbGraphStartPathAnalysis(int** context, int algorithm, int maxDepth,
                                 int originSet, int edgeSet,
                                 int destinationSet, boolean reverse,
                                 const char* condition);
 
   
   int TdbGraphPathAnalysisStep(int* context);
 
   
   int TdbGraphClosePathAnalysis(int** context);
 

   int TdbGraphAnalysisSnapshot(int* context, int* count, int mode);
   

   int TdbGraphNextPath(int* context, char** database, int* recordId);
 

   int TdbGraphGetPath(int* context, char** edge, double* weight,
                       char** database, int* recordId);
   
   
   int TdbGraphRecAssoc(TdbHandle* recordControl, const char* recordName,
                        const char* edgeName, TdbHandle sourceRecord,
                        TdbHandle targetRecord, double weight);
 
   
   int TdbGraphAddVertex(TdbHandle* recordControl, const char* recordName,
                         const char* label, TdbHandle referenceRecord);
   
   
#ifndef DOXYGEN_SHOULD_SKIP_THIS
   int TdbGraphQuery(int* resultSet, int* setType, int* recordCount,
                     const char* query);
#endif
 
 
   // ------------------------------------------------------------------------


   int TdbPutXmlBuffer(TdbHandle recordControl, boolean storeCopy,
      boolean validate, const char* xmldata, int length);
 

   int TdbPutJsonBuffer(TdbHandle recordControl, const char* jsondata, int length);
 

   int TdbPutXmlFile(TdbHandle recordControl, boolean storeCopy,
      boolean validate, const char* xmlfile);
 

   int TdbPutJsonFile(TdbHandle recordControl, const char* jsonfile);
 

   int TdbGetXmlBuffer(TdbHandle recordControl, char** xmldata, int* length);
 

   int TdbGetJsonBuffer(TdbHandle recordControl, char** jsondata, int* length);
 

   int TdbExecuteXPath(const char* xpath, int* searchSet);
 

   int TdbGetXmlFragments(int searchSetNo, const char* xpath,
      int startRis, int endRis, boolean highlight,
      void** buffer, int* length);
 
 
 
   // ------------------------------------------------------------------------
   
   

   int TdbDeallocate(void* buf);
   

   int TdbOpenBase(char* base);
   
   
   int TdbOpenBaseQuota(int* bases);
 

   int TdbExtractTextFromField(TdbHandle recordControl,
      int partNumber,
      const char* targetFieldName,
      const char* propertyNameField,
      const char* propertyValueField,
      const char* sourceFieldName,
      const char* fileName);

   int TdbExtractTextFromFile(TdbHandle recordControl,
      int partNumber,
      const char* targetTextFieldName,
      const char* propertyNameField,
      const char* propertyValueField,
      const char* targetStringFieldName,
      const char* fileName);

   int TdbExtractTextFromMem(TdbHandle recordControl,
      int partNumber,
      const char* targetFieldName,
      const char* propertyNameField,
      const char* propertyValueField,
      const char* targetStringFieldName,
      unsigned char* filedata,
      size_t fileDataSize,
      const char* fileName);
 
 
 
    // ------------------------------------------------------------------------

 
   
   TDB_DEPRECATED("Deprecated by TdbStartTrip")
   int TdbBeginTdbs(shell_dao_rec* shell_dao, boolean restart);
   
   
   TDB_DEPRECATED("Deprecated by TdbStopTrip")
   int TdbEndTdbs(boolean restart);
 
   
   TDB_DEPRECATED("Deprecated by TdbCopyBaseDesign")
   int TdbCopyBaseDef(char* old_base, char* new_base,
                      base_spec_rec* base_specification);

   TDB_DEPRECATED("Deprecated by TdbCopyThesDesign")
   int TdbCopyThesDef(const char* old_thes, const char* new_thes,
                      base_spec_rec* thes_specification);
   

   TDB_DEPRECATED("Deprecated by TdbExecuteCcl")
   int TdbDaoOrder(int* order);
 
   
   TDB_DEPRECATED("Deprecated by TdbDeleteBaseField")
   int TdbDeleteFieldSpec(field_spec_rec* fldspec);
   
    
    int TdbGetBaseInfo(char* base, char* recordNameField, int* flags);
    
   
   TDB_DEPRECATED("Deprecated by TdbGetBaseDesign")
   int TdbGetBaseDef(char* base, base_spec_rec* baseSpecification);
 
   
    TDB_DEPRECATED("Deprecated without replacement")
    int TdbGetDefragStatus(const char* base, boolean* baf, boolean* bif,
                           boolean* vif);
    
    

   TDB_DEPRECATED("Deprecated by TdbGetBaseField")
   int TdbGetFieldName(field_spec_rec *field_specification, int ordinal);
   
   TDB_DEPRECATED("Deprecated by TdbGetBaseField")
   int TdbGetFieldSpec(field_spec_rec* fieldSpec);
   
   
   TDB_DEPRECATED("Deprecated by TdbPutBaseDesign")
   int TdbPutBaseDef(base_spec_rec* baseSpec);
   
   
   TDB_DEPRECATED("Deprecated by TdbPutBaseField and TdbCloseBaseField")
   int TdbPutFieldSpec(field_spec_rec* fieldSpec);
 
   
   TDB_DEPRECATED("Deprecated by TdbGetThesDesign")
   int TdbGetThesDef(char* thesaurus, base_spec_rec* thesaurusSpec);

   TDB_DEPRECATED("Deprecated by TdbPutBaseProperty")
   int TdbDefineXml(boolean xml);
 
   
   TDB_DEPRECATED("Deprecated by TdbPutBaseProperty")
   int TdbDefineGraph(base_spec_rec* base_spec, boolean enable);
 

   TDB_DEPRECATED("Deprecated by TdbPutThesDesign")
   int TdbPutThesDef(base_spec_rec* thesaurusSpec);
 

   TDB_DEPRECATED("Deprecated by TdbSearchInfo")
   int TdbGetSearch(int* search, int* record_count, int* hit_count);
 
   
   TDB_DEPRECATED("Deprecated by TdbSearchInfo")
   int TdbSearchResult(int* searchNumber, int* recordCount, int*hitCount,
                       char** cclOrder, int* length);
 
   
   TDB_DEPRECATED("Deprecated by TdbGetClusterDesign")
   int TdbGetDbCluster(char* cluster, cluster_spec_rec* clusterSpecification);
 
   
   TDB_DEPRECATED("Deprecated by TdbPutClusterDesign")
   int TdbPutDbCluster(cluster_spec_rec* clusterSpec);
 
   
   TDB_DEPRECATED("Deprecated by TdbSessionInfo and TdbUserInfo")
   int TdbGetSessionInfo(char* run_time, Char* logged_in,
                         Char* FM, Char* UM, Char* SM);
 
   
   TDB_DEPRECATED("Deprecated by TdbGetNextProcLine")
   int TdbNextRunCommand(void);
 

   TDB_DEPRECATED("Deprecated by TdbExecuteCcl")
   int TdbShellDaoPtr(shell_dao_rec** shell_dao);
 
   
   TDB_DEPRECATED("Deprecated by TdbStartTrip and TdbShellModifyCcl")
   int TdbShellInit(int language);
 
   
   TDB_DEPRECATED("Deprecated by TdbExecuteCcl and TdbGetParsedCcl")
   int TdbShellToDao(shell_dao_rec* shell_dao);
 
   
   
#if defined(__cplusplus)
}
#endif
 
#endif