windows-server-2003/admin/admt/common/include/msjro.tli

// Created by Microsoft (R) C/C++ Compiler Version 12.00.8867.0 (31ae8eb7).
//
// c:\dev\admt\dbmgr\debug\msjro.tli
//
// Wrapper implementations for Win32 type library msjro.dll
// compiler-generated file created 02/13/01 at 16:18:05 - DO NOT EDIT!

#pragma once

//
// interface IReplica wrapper method implementations
//

void IReplica::PutRefActiveConnection ( IDispatch * ppconn ) {
    HRESULT _hr = putref_ActiveConnection(ppconn);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

void IReplica::PutActiveConnection ( const _variant_t & ppconn ) {
    HRESULT _hr = put_ActiveConnection(ppconn);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

IDispatchPtr IReplica::GetActiveConnection ( ) {
    IDispatch * _result;
    HRESULT _hr = get_ActiveConnection(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IDispatchPtr(_result, false);
}

_bstr_t IReplica::GetConflictFunction ( ) {
    BSTR _result;
    HRESULT _hr = get_ConflictFunction(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

void IReplica::PutConflictFunction ( _bstr_t pbstr ) {
    HRESULT _hr = put_ConflictFunction(pbstr);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

_RecordsetPtr IReplica::GetConflictTables ( ) {
    struct _Recordset * _result;
    HRESULT _hr = get_ConflictTables(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _RecordsetPtr(_result, false);
}

_variant_t IReplica::GetDesignMasterId ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_DesignMasterId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

void IReplica::PutDesignMasterId ( const _variant_t & pvar ) {
    HRESULT _hr = put_DesignMasterId(pvar);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

long IReplica::GetPriority ( ) {
    long _result;
    HRESULT _hr = get_Priority(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

_variant_t IReplica::GetReplicaId ( ) {
    VARIANT _result;
    VariantInit(&_result);
    HRESULT _hr = get_ReplicaId(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _variant_t(_result, false);
}

enum ReplicaTypeEnum IReplica::GetReplicaType ( ) {
    enum ReplicaTypeEnum _result;
    HRESULT _hr = get_ReplicaType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

long IReplica::GetRetentionPeriod ( ) {
    long _result;
    HRESULT _hr = get_RetentionPeriod(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

void IReplica::PutRetentionPeriod ( long pl ) {
    HRESULT _hr = put_RetentionPeriod(pl);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
}

enum VisibilityEnum IReplica::GetVisibility ( ) {
    enum VisibilityEnum _result;
    HRESULT _hr = get_Visibility(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

HRESULT IReplica::CreateReplica ( _bstr_t replicaName, _bstr_t description, enum ReplicaTypeEnum ReplicaType, enum VisibilityEnum Visibility, long Priority, enum UpdatabilityEnum updatability ) {
    HRESULT _hr = raw_CreateReplica(replicaName, description, ReplicaType, Visibility, Priority, updatability);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

VARIANT_BOOL IReplica::GetObjectReplicability ( _bstr_t objectName, _bstr_t objectType ) {
    VARIANT_BOOL _result;
    HRESULT _hr = raw_GetObjectReplicability(objectName, objectType, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

HRESULT IReplica::SetObjectReplicability ( _bstr_t objectName, _bstr_t objectType, VARIANT_BOOL replicability ) {
    HRESULT _hr = raw_SetObjectReplicability(objectName, objectType, replicability);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

HRESULT IReplica::MakeReplicable ( _bstr_t connectionString, VARIANT_BOOL columnTracking ) {
    HRESULT _hr = raw_MakeReplicable(connectionString, columnTracking);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

HRESULT IReplica::PopulatePartial ( _bstr_t FullReplica ) {
    HRESULT _hr = raw_PopulatePartial(FullReplica);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

HRESULT IReplica::Synchronize ( _bstr_t target, enum SyncTypeEnum syncType, enum SyncModeEnum syncMode ) {
    HRESULT _hr = raw_Synchronize(target, syncType, syncMode);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

FiltersPtr IReplica::GetFilters ( ) {
    struct Filters * _result;
    HRESULT _hr = get_Filters(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return FiltersPtr(_result, false);
}

//
// interface Filters wrapper method implementations
//

HRESULT Filters::Refresh ( ) {
    HRESULT _hr = raw_Refresh();
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

IUnknownPtr Filters::_NewEnum ( ) {
    IUnknown * _result;
    HRESULT _hr = raw__NewEnum(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return IUnknownPtr(_result, false);
}

long Filters::GetCount ( ) {
    long _result;
    HRESULT _hr = get_Count(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

FilterPtr Filters::GetItem ( const _variant_t & Index ) {
    struct Filter * _result;
    HRESULT _hr = get_Item(Index, &_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return FilterPtr(_result, false);
}

HRESULT Filters::Append ( _bstr_t TableName, enum FilterTypeEnum FilterType, _bstr_t FilterCriteria ) {
    HRESULT _hr = raw_Append(TableName, FilterType, FilterCriteria);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

HRESULT Filters::Delete ( const _variant_t & Index ) {
    HRESULT _hr = raw_Delete(Index);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

//
// interface Filter wrapper method implementations
//

_bstr_t Filter::GetTableName ( ) {
    BSTR _result;
    HRESULT _hr = get_TableName(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

enum FilterTypeEnum Filter::GetFilterType ( ) {
    enum FilterTypeEnum _result;
    HRESULT _hr = get_FilterType(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _result;
}

_bstr_t Filter::GetFilterCriteria ( ) {
    BSTR _result;
    HRESULT _hr = get_FilterCriteria(&_result);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _bstr_t(_result, false);
}

//
// interface IJetEngine wrapper method implementations
//

HRESULT IJetEngine::CompactDatabase ( _bstr_t SourceConnection, _bstr_t Destconnection ) {
    HRESULT _hr = raw_CompactDatabase(SourceConnection, Destconnection);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}

HRESULT IJetEngine::RefreshCache ( struct _Connection * Connection ) {
    HRESULT _hr = raw_RefreshCache(Connection);
    if (FAILED(_hr)) _com_issue_errorex(_hr, this, __uuidof(this));
    return _hr;
}