dao360.tli

一个模板打印的源程序。可用于医院诊断报告的打印。

    HRESULT _hr = raw_BeginTrans();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT Workspace::CommitTrans ( long Options ) {
    HRESULT _hr = raw_CommitTrans(Options);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT Workspace::Close ( ) {
    HRESULT _hr = raw_Close();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT Workspace::Rollback ( ) {
    HRESULT _hr = raw_Rollback();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline DatabasePtr Workspace::OpenDatabase ( _bstr_t Name, const _variant_t & Options, const _variant_t & ReadOnly, const _variant_t & Connect ) {
    struct Database * _result;
    HRESULT _hr = raw_OpenDatabase(Name, Options, ReadOnly, Connect, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return DatabasePtr(_result, false);
}

inline DatabasePtr Workspace::CreateDatabase ( _bstr_t Name, _bstr_t Connect, const _variant_t & Option ) {
    struct Database * _result;
    HRESULT _hr = raw_CreateDatabase(Name, Connect, Option, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return DatabasePtr(_result, false);
}

inline _UserPtr Workspace::CreateUser ( const _variant_t & Name, const _variant_t & PID, const _variant_t & Password ) {
    struct _User * _result;
    HRESULT _hr = raw_CreateUser(Name, PID, Password, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _UserPtr(_result, false);
}

inline _GroupPtr Workspace::CreateGroup ( const _variant_t & Name, const _variant_t & PID ) {
    struct _Group * _result;
    HRESULT _hr = raw_CreateGroup(Name, PID, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _GroupPtr(_result, false);
}

inline ConnectionPtr Workspace::OpenConnection ( _bstr_t Name, const _variant_t & Options, const _variant_t & ReadOnly, const _variant_t & Connect ) {
    struct Connection * _result;
    HRESULT _hr = raw_OpenConnection(Name, Options, ReadOnly, Connect, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ConnectionPtr(_result, false);
}

inline long Workspace::GetLoginTimeout ( ) {
    long _result;
    HRESULT _hr = get_LoginTimeout(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void Workspace::PutLoginTimeout ( long pTimeout ) {
    HRESULT _hr = put_LoginTimeout(pTimeout);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long Workspace::GetDefaultCursorDriver ( ) {
    long _result;
    HRESULT _hr = get_DefaultCursorDriver(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void Workspace::PutDefaultCursorDriver ( long pCursorType ) {
    HRESULT _hr = put_DefaultCursorDriver(pCursorType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline long Workspace::GethEnv ( ) {
    long _result;
    HRESULT _hr = get_hEnv(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline long Workspace::GetType ( ) {
    long _result;
    HRESULT _hr = get_Type(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline ConnectionsPtr Workspace::GetConnections ( ) {
    struct Connections * _result;
    HRESULT _hr = get_Connections(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ConnectionsPtr(_result, false);
}

//
// interface Databases wrapper method implementations
//

inline DatabasePtr Databases::GetItem ( const _variant_t & Item ) {
    struct Database * _result;
    HRESULT _hr = get_Item(Item, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return DatabasePtr(_result, false);
}

//
// interface Database wrapper method implementations
//

inline long Database::GetCollatingOrder ( ) {
    long _result;
    HRESULT _hr = get_CollatingOrder(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t Database::GetConnect ( ) {
    BSTR _result;
    HRESULT _hr = get_Connect(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t Database::GetName ( ) {
    BSTR _result;
    HRESULT _hr = get_Name(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline short Database::GetQueryTimeout ( ) {
    short _result;
    HRESULT _hr = get_QueryTimeout(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline void Database::PutQueryTimeout ( short ps ) {
    HRESULT _hr = put_QueryTimeout(ps);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline VARIANT_BOOL Database::GetTransactions ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_Transactions(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline VARIANT_BOOL Database::GetUpdatable ( ) {
    VARIANT_BOOL _result;
    HRESULT _hr = get_Updatable(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline _bstr_t Database::GetVersion ( ) {
    BSTR _result;
    HRESULT _hr = get_Version(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline long Database::GetRecordsAffected ( ) {
    long _result;
    HRESULT _hr = get_RecordsAffected(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline TableDefsPtr Database::GetTableDefs ( ) {
    struct TableDefs * _result;
    HRESULT _hr = get_TableDefs(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return TableDefsPtr(_result, false);
}

inline QueryDefsPtr Database::GetQueryDefs ( ) {
    struct QueryDefs * _result;
    HRESULT _hr = get_QueryDefs(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return QueryDefsPtr(_result, false);
}

inline RelationsPtr Database::GetRelations ( ) {
    struct Relations * _result;
    HRESULT _hr = get_Relations(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RelationsPtr(_result, false);
}

inline ContainersPtr Database::GetContainers ( ) {
    struct Containers * _result;
    HRESULT _hr = get_Containers(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ContainersPtr(_result, false);
}

inline RecordsetsPtr Database::GetRecordsets ( ) {
    struct Recordsets * _result;
    HRESULT _hr = get_Recordsets(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetsPtr(_result, false);
}

inline HRESULT Database::Close ( ) {
    HRESULT _hr = raw_Close();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT Database::Execute ( _bstr_t Query, const _variant_t & Options ) {
    HRESULT _hr = raw_Execute(Query, Options);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline RecordsetPtr Database::_30_OpenRecordset ( _bstr_t Name, const _variant_t & Type, const _variant_t & Options ) {
    struct Recordset * _result;
    HRESULT _hr = raw__30_OpenRecordset(Name, Type, Options, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetPtr(_result, false);
}

inline PropertyPtr Database::CreateProperty ( const _variant_t & Name, const _variant_t & Type, const _variant_t & Value, const _variant_t & DDL ) {
    struct Property * _result;
    HRESULT _hr = raw_CreateProperty(Name, Type, Value, DDL, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return PropertyPtr(_result, false);
}

inline _RelationPtr Database::CreateRelation ( const _variant_t & Name, const _variant_t & Table, const _variant_t & ForeignTable, const _variant_t & Attributes ) {
    struct _Relation * _result;
    HRESULT _hr = raw_CreateRelation(Name, Table, ForeignTable, Attributes, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _RelationPtr(_result, false);
}

inline _TableDefPtr Database::CreateTableDef ( const _variant_t & Name, const _variant_t & Attributes, const _variant_t & SourceTableName, const _variant_t & Connect ) {
    struct _TableDef * _result;
    HRESULT _hr = raw_CreateTableDef(Name, Attributes, SourceTableName, Connect, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _TableDefPtr(_result, false);
}

inline HRESULT Database::BeginTrans ( ) {
    HRESULT _hr = raw_BeginTrans();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT Database::CommitTrans ( long Options ) {
    HRESULT _hr = raw_CommitTrans(Options);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT Database::Rollback ( ) {
    HRESULT _hr = raw_Rollback();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline RecordsetPtr Database::CreateDynaset ( _bstr_t Name, const _variant_t & Options, const _variant_t & Inconsistent ) {
    struct Recordset * _result;
    HRESULT _hr = raw_CreateDynaset(Name, Options, Inconsistent, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetPtr(_result, false);
}

inline _QueryDefPtr Database::CreateQueryDef ( const _variant_t & Name, const _variant_t & SQLText ) {
    struct _QueryDef * _result;
    HRESULT _hr = raw_CreateQueryDef(Name, SQLText, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _QueryDefPtr(_result, false);
}

inline RecordsetPtr Database::CreateSnapshot ( _bstr_t Source, const _variant_t & Options ) {
    struct Recordset * _result;
    HRESULT _hr = raw_CreateSnapshot(Source, Options, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetPtr(_result, false);
}

inline HRESULT Database::DeleteQueryDef ( _bstr_t Name ) {
    HRESULT _hr = raw_DeleteQueryDef(Name);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline long Database::ExecuteSQL ( _bstr_t SQL ) {
    long _result;
    HRESULT _hr = raw_ExecuteSQL(SQL, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

inline RecordsetPtr Database::ListFields ( _bstr_t Name ) {
    struct Recordset * _result;
    HRESULT _hr = raw_ListFields(Name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetPtr(_result, false);
}

inline RecordsetPtr Database::ListTables ( ) {
    struct Recordset * _result;
    HRESULT _hr = raw_ListTables(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetPtr(_result, false);
}

inline _QueryDefPtr Database::OpenQueryDef ( _bstr_t Name ) {
    struct _QueryDef * _result;
    HRESULT _hr = raw_OpenQueryDef(Name, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _QueryDefPtr(_result, false);
}

inline RecordsetPtr Database::OpenTable ( _bstr_t Name, const _variant_t & Options ) {
    struct Recordset * _result;
    HRESULT _hr = raw_OpenTable(Name, Options, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetPtr(_result, false);
}

inline _bstr_t Database::GetReplicaID ( ) {
    BSTR _result;
    HRESULT _hr = get_ReplicaID(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline _bstr_t Database::GetDesignMasterID ( ) {
    BSTR _result;
    HRESULT _hr = get_DesignMasterID(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

inline void Database::PutDesignMasterID ( _bstr_t pbstr ) {
    HRESULT _hr = put_DesignMasterID(pbstr);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT Database::Synchronize ( _bstr_t DbPathName, const _variant_t & ExchangeType ) {
    HRESULT _hr = raw_Synchronize(DbPathName, ExchangeType);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline HRESULT Database::MakeReplica ( _bstr_t PathName, _bstr_t Description, const _variant_t & Options ) {
    HRESULT _hr = raw_MakeReplica(PathName, Description, Options);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline void Database::PutConnect ( _bstr_t pbstr ) {
    HRESULT _hr = put_Connect(pbstr);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

inline HRESULT Database::NewPassword ( _bstr_t bstrOld, _bstr_t bstrNew ) {
    HRESULT _hr = raw_NewPassword(bstrOld, bstrNew);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

inline RecordsetPtr Database::OpenRecordset ( _bstr_t Name, const _variant_t & Type, const _variant_t & Options, const _variant_t & LockEdit ) {
    struct Recordset * _result;
    HRESULT _hr = raw_OpenRecordset(Name, Type, Options, LockEdit, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return RecordsetPtr(_result, false);
}

inline ConnectionPtr Database::GetConnection ( ) {
    struct Connection * _result;
    HRESULT _hr = get_Connection(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return ConnectionPtr(_result, false);