4. Fehlermeldung

Fehlermeldung

  • H

    Mensch Jung, lern mal einen Debugger zu benutzen und nenn uns die Zeile, bei der der Absturz passiert!

    Dafür sind Debugger da!

    0
  • S

    mich haut es bei der Zeile raus:

    CSDBStreamDataSet *pVal = pSDBase->OpenStreamDataSet(pChn->GetTableName(),pChn->GetDataType(),pChn->CalcChannelValSize());

    und somit funktioniert nachfolgender Text auch nicht mehr

    0
  • S

    kann mir den niemand helfen??

    0
  • M

    Prüf doch einfach mal den Rückgabewert von OpenStreamChannel in der Zeile davor.

    0
  • S

    da kommt ja eine Speicheradresse zurück, also das funktioniert noch, nur irgendwie greift er dann nicht drauf zu 😕

    0
  • M

    Original erstellt von sonnenschein1984:
    da kommt ja eine Speicheradresse zurück, also das funktioniert noch,

    Hast du das mit dem Debugger geprüft? Wie lautet denn die zurückgegebene Adresse?

    0
  • S

    0x01896630 das ist die Adresse, kannst du damit mehr anfangen???

    0
  • D

    Zeig uns mal die Zeile, in der er WIRKLICH abstürzt. Die Zeile, die du angibst ist ja nmur ein Funktionsaufruf ... Er stürzt aber in dieser Funktion ab, was man auch an der Fehlermeldung sehen kann. Poste also einfach mal die Zeile, die die Meldung angibt MIT CODETAGS!!!

    0
  • M

    Die Adresse sieht ganz gut aus. Wie lautet denn die genaue Fehlermeldung? In deinem ersten Beitrag hast die ja nur unvollständig angegeben.

    0
  • S

    Fehlermeldung:

    Debug Assertion Failed!
    Program:D:\Name\Ordner\debug\name.exe
    File: C:\Src\SdbCtrl_70\SdbCtrl\SdbStreamDataSet.cpp
    Line: 729

    Und dann kommt abbrechen, wiederholen und ignorieren!!!

    0
  • D

    Original erstellt von dEUs:
    Zeig uns mal die Zeile, in der er WIRKLICH abstürzt. Die Zeile, die du angibst ist ja nmur ein Funktionsaufruf ... Er stürzt aber in dieser Funktion ab, was man auch an der Fehlermeldung sehen kann. Poste also einfach mal die Zeile, die die Meldung angibt MIT CODETAGS!!!

    0
  • M

    Original erstellt von sonnenschein1984:
    Debug Assertion Failed!
    Program:D:\Name\Ordner\debug\name.exe
    File: C:\Src\SdbCtrl_70\SdbCtrl\SdbStreamDataSet.cpp
    Line: 729

    Ja dann zeig uns doch endlich mal den Code in dieser Zeile, am besten mit ein wenig Umfeld! Und Code-Tags!

    0
  • S

    void auslesen()
    {
    /*ifstream is;
    is.open(filename); //Datei zum lesen öffnen

    /while (is.good()) //überprüfen ob für E/A-Funktionen geeignet
    {
    c = is.get(); //auslesen
    cout << c;endl;
    }    /

    //Auslesen

    //CSDBase *OpenSimplorerDataBase(LPCTSTR lpszName);

    virtual CSDBStreamDataSet::Load(); //Datei laden
    long CSDBStreamDataSet::GetNumberOfEntries(); //Anzahl der Stützstellen

    //Datei auslesen in einem Block
    CSDBase *pSDBase = NULL;
    void *pdValues = NULL;

    pSDBase = OpenSimplorerDataBase(filename);

    CSDBStreamExp *pExp = NULL;
    pExp = pSDBase->OpenStreamExp();

    CSDBStreamRun *pRun = pSDBase->OpenStreamRun(pExp->GetTableName());
    CSDBStreamAnalysis *pAna= pSDBase->OpenStreamAnalysis(pRun->GetTableName());
    CSDBStreamChannel *pChn = pSDBase->OpenStreamChannel(pAna->GetTableName());

    cout<<"pExp="; cout<<pExp<<endl;
    cout<<"pRun="; cout<<pRun<<endl;
    cout<<"pAna="; cout<<pAna<<endl;
    cout<<"pChn="; cout<<pChn<<endl;

    //BIS DAHIN GEHTS

    CSDBStreamDataSet *OpenStreamDataSet(LPCTSTR lpszStreamName,long lDataType = STREAM_CHN_DATATYPE_REAL, long lChannelValSize = 0, BOOL bCreate = FALSE );

    CSDBStreamDataSet *pVal = pSDBase->OpenStreamDataSet(pChn->GetTableName(),pChn->GetDataType(),pChn->CalcChannelValSize());

    double dAnzahlStuetzstellen=pVal->GetNumberOfEntries();
    pdValues = new double[dAnzahlStuetzstellen];

    pSDBase->ReadDataSetBlock((void*)pdValues,pVal,STREAM_BLOCK_REDUCE,dAnzahlStuetzstellen);

    //BasisChannel bestimmen
    CString strBasisChannel;
    strBasisChannel = pAna->GetBaseChannelName();

    }

    0
  • M

    Komisch, da steht nirgendwo ein assert oder etwas ähnliches 🙄

    Nochmal zum Mitschreiben:

    Diese Datei:
    File: C:\Src\SdbCtrl_70\SdbCtrl\SdbStreamDataSet.cpp

    Diese Zeile:
    Line: 729

    Und CODE-TAGS. Das kann doch nicht so schwierig sein!

    [ Dieser Beitrag wurde am 17.06.2003 um 13:49 Uhr von MFK editiert. ]

    0
  • D

    sonnenschein, es ist extrem unspassig dir zu helfen!!

    0
  • H

    Was spielt ihr hier für ein Spiel?

    Sieht lustig aus....

    Solange er keine richtigen Infos rausrückt würde ich den Thread komplett ignorieren..... und irgendwann kapiert er auch was CODETAGS sind, ganz sicher... bzw. was der blaue C++ CODE Button unter dem Antwortfeld macht... ich hab da noch Hoffnung, ehrlich.... irgendwann rafft auch er das...

    0
  • S

    #include "stdafx.h"

    #include "SimplorerDataBase.h"
    #include "SimplorerDataBase_Basis.h"
    #include "SimplorerDataBase_Error.h"

    #include <stdio.h>
    #include <vector>

    using namespace std;

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    // CSDBStreamDataSet
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    CSDBStreamDataSet::CSDBStreamDataSet( CSDBase *pSDBase, LPCTSTR lpszStreamName, eSDBStreamModeType eSDBStreamMode, long lDataType, long lChannelValSize ) : CSDBStreamBase( pSDBase, lpszStreamName, eSDBStreamMode )
    {
    // initialize internal values
    m_lDataType = lDataType;

    m_ullSeekPos = (ULONGLONG)0;
    m_ullSize = (ULONGLONG)0;

    // REAL
    m_sDataSet_REAL.dRealVal = 0;
    m_sDataSet_REAL.lID = 0;
    // CPLX
    m_sDataSet_CPLX.dRealVal = 0;
    m_sDataSet_CPLX.dImagVal = 0;
    m_sDataSet_CPLX.lID = 0;
    // INTG/ENUM
    m_sDataSet_INTG.iIntegVal = 0;
    m_sDataSet_INTG.lID = 0;
    // CHAR
    m_sDataSet_CHAR.cCharVal = 0;
    m_sDataSet_CHAR.lID = 0;
    // FREE/RECORD/ARRAY
    m_sDataSet_FREE.m_pChannelVal = NULL;
    m_sDataSet_FREE.lID = 0;

    //MK@130502
    m_lChannelValSize = lChannelValSize;
    m_pChannelVal = NULL;

    m_pdRealVal = NULL;
    m_pdImagVal = NULL;
    m_piIntegVal = NULL;
    m_pcCharVal = NULL;
    m_ppChannelVal = NULL;
    m_plID = NULL;
    m_pReadBuffer = NULL;

    switch( m_lDataType )
    {
    case STREAM_CHN_DATATYPE_REAL : m_pdRealVal = &m_sDataSet_REAL.dRealVal;
    m_plID = &m_sDataSet_REAL.lID;

    m_pReadBuffer = new CDataSetReadBuffer(this,pSDBase);
    break;

    case STREAM_CHN_DATATYPE_CPLX : m_pdRealVal = &m_sDataSet_CPLX.dRealVal;
    m_pdImagVal = &m_sDataSet_CPLX.dImagVal;
    m_plID = &m_sDataSet_CPLX.lID;

    m_pReadBuffer = new CDataSetReadBuffer(this,pSDBase);
    break;
    case STREAM_CHN_DATATYPE_ENUM:
    case STREAM_CHN_DATATYPE_INTEG: m_piIntegVal= &m_sDataSet_INTG.iIntegVal;
    m_plID = &m_sDataSet_INTG.lID;

    m_pReadBuffer = new CDataSetReadBuffer(this,pSDBase);
    break;
    case STREAM_CHN_DATATYPE_CHAR: m_pcCharVal = &m_sDataSet_CHAR.cCharVal;
    m_plID = &m_sDataSet_CHAR.lID;

    m_pReadBuffer = new CDataSetReadBuffer(this,pSDBase);
    break;
    case STREAM_CHN_DATATYPE_FREE:
    case STREAM_CHN_DATATYPE_ARRAY:
    case STREAM_CHN_DATATYPE_RECORD:
    {
    m_ppChannelVal = &m_sDataSet_FREE.m_pChannelVal;
    m_plID = &m_sDataSet_FREE.lID;

    m_sDataSet_FREE.m_pChannelVal = NULL;
    // Zwischenspeicher für store_reduce()
    m_pChannelVal = NULL;

    m_pReadBuffer = new CDataSetReadBuffer(this,pSDBase);
    break;
    }

    default:
    break;
    }
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    CSDBStreamDataSet::~CSDBStreamDataSet()
    {
    if( m_pChannelVal )
    {
    delete[] m_pChannelVal;
    m_pChannelVal = NULL;
    }

    sVecBuffer_REAL.clear();
    sVecBuffer_CPLX.clear();
    sVecBuffer_INTG.clear();
    sVecBuffer_CHAR.clear();
    sVecBuffer_FREE.clear();

    if( m_pReadBuffer )
    {
    delete m_pReadBuffer;
    m_pReadBuffer = NULL;
    }

    // if( *m_ppChannelVal )
    // {
    // delete[] *m_ppChannelVal;
    // *m_ppChannelVal = NULL;
    // }

    if( m_sDataSet_FREE.m_pChannelVal )
    {
    delete[] m_sDataSet_FREE.m_pChannelVal;
    m_sDataSet_FREE.m_pChannelVal = NULL;
    }
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Load
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::iLoad( COleStreamFile* pOleStreamFile )
    {
    try
    {
    //CArchive arc(pOleStreamFile, CArchive::load);

    switch( m_lDataType )
    {
    case STREAM_CHN_DATATYPE_REAL : //pOleStreamFile->Read( &m_dRealVal, sizeof(double) );
    pOleStreamFile->Read( &m_sDataSet_REAL, sizeof(sDataSet_REAL) );
    break;

    case STREAM_CHN_DATATYPE_CPLX : //pOleStreamFile->Read( &m_dRealVal, sizeof(double) );
    //pOleStreamFile->Read( &m_dImagVal, sizeof(double) );
    pOleStreamFile->Read( &m_sDataSet_CPLX, sizeof(sDataSet_CPLX) );
    break;

    case STREAM_CHN_DATATYPE_FREE:
    case STREAM_CHN_DATATYPE_ARRAY:
    case STREAM_CHN_DATATYPE_RECORD:
    { //
    if( *m_ppChannelVal )
    {
    delete[] *m_ppChannelVal;
    *m_ppChannelVal = NULL;
    }

    //
    if( m_lChannelValSize )
    {
    *m_ppChannelVal = new BYTE[m_lChannelValSize];
    pOleStreamFile->Read( *m_ppChannelVal, m_lChannelValSize );
    }
    else
    *m_ppChannelVal = NULL;

    if(m_pSDBase->GetVersion()>=STREAM_VERSION_NUMBER_3)
    {
    pOleStreamFile->Read( m_plID, sizeof(long) );
    //arc >> m_lID;
    }
    else
    {
    *m_plID=1;
    }

    break;
    }
    case STREAM_CHN_DATATYPE_ENUM:
    case STREAM_CHN_DATATYPE_INTEG: pOleStreamFile->Read( &m_sDataSet_INTG, sizeof(sDataSet_INTG) );
    break;
    case STREAM_CHN_DATATYPE_CHAR: pOleStreamFile->Read( &m_sDataSet_CHAR, sizeof(sDataSet_CHAR) );
    break;
    }
    }
    catch(...)
    {
    SetLastSDBError( SDB_EXP_STREAM_COULD_NOT_LOAD );
    ReInitValues();
    return FALSE;
    }

    return TRUE;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Store_MK@080102
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::Store()
    {
    // wenn max. Größe des Write-Puffers eines DataSet-Streams überschritten
    // --> alles in die SDB flushen
    if( ((sVecBuffer_REAL.size()*SIZE_SET_REAL) > _MAX_SET_BUF_SIZE_WRITE)
    //||
    //((sVecBuffer_CPLX.size()*SIZE_SET_CPLX) > _MAX_SET_BUF_SIZE_WRITE)
    )
    {
    m_pSDBase->Flush();
    }

    try
    {
    switch( m_lDataType )
    {
    case STREAM_CHN_DATATYPE_REAL :
    {
    sVecBuffer_REAL.push_back( m_sDataSet_REAL );
    break;
    }
    case STREAM_CHN_DATATYPE_CPLX :
    {
    sVecBuffer_CPLX.push_back( m_sDataSet_CPLX );
    break;
    }
    case STREAM_CHN_DATATYPE_FREE :
    case STREAM_CHN_DATATYPE_ARRAY :
    case STREAM_CHN_DATATYPE_RECORD :
    {
    COleStreamFile *pOleStreamFile = m_pStreamBuf->GetOleStreamFile();
    pOleStreamFile->SeekToEnd();

    if( m_lChannelValSize )
    pOleStreamFile->Write( *m_ppChannelVal, m_lChannelValSize );

    pOleStreamFile->Write( m_plID, sizeof(long) );

    break;
    }

    case STREAM_CHN_DATATYPE_ENUM :
    case STREAM_CHN_DATATYPE_INTEG :
    {
    sVecBuffer_INTG.push_back( m_sDataSet_INTG );
    break;
    }
    case STREAM_CHN_DATATYPE_CHAR :
    {
    sVecBuffer_CHAR.push_back( m_sDataSet_CHAR );
    break;
    }
    }

    return TRUE;
    }
    catch(...)
    {
    SetLastSDBError( SDB_SET_STREAM_COULD_NOT_STORE );
    return FALSE;
    }

    return TRUE;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::Store( double dRealVal, long lID )
    {
    //MK@170502
    ASSERT( m_lDataType == STREAM_CHN_DATATYPE_REAL );

    Set( dRealVal, lID );

    return Store();
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::Store( double dRealVal, double dImagVal, long lID )
    {
    //MK@170502
    ASSERT( m_lDataType == STREAM_CHN_DATATYPE_CPLX );

    Set( dRealVal, dImagVal, lID );

    return Store();
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //MK@130502
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //BOOL CSDBStreamDataSet::Store( LPCTSTR lpszStringVal, long lID )
    //{
    // Set( lpszStringVal, lID );
    //
    // return Store();
    //}

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::CreateStream()
    {
    if( !m_pSDBase || !m_pSDBase->m_pStorageRoot || !m_pSDBase->GetStorageDataSet() )
    return FALSE;

    return CreateStreamFile( m_pSDBase->GetStorageDataSet()->GetStorage() );
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::OpenStream()
    {
    if( !m_pSDBase || !m_pSDBase->m_pStorageRoot || !m_pSDBase->GetStorageDataSet() )
    return FALSE;

    return OpenStreamFile( m_pSDBase->GetStorageDataSet()->GetStorage() );
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    ULARGE_INTEGER CSDBStreamDataSet::GetBufSize()
    {
    ULARGE_INTEGER uli1; uli1.QuadPart = (ULONGLONG)0;

    if( !m_pStreamBuf )
    return uli1;

    return m_pStreamBuf->GetSize();
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::ReInitValues()
    {
    CSDBStreamBase::ReInitValues();

    //m_dRealVal = 0.0;
    //m_dImagVal = 0.0;
    //MK@130502 m_strStringVal.Empty();

    //m_iIntegVal = 0;

    //MK@210502
    //m_cCharVal = 0;

    m_lChannelValSize = 0;

    if( m_pChannelVal )
    {
    delete[] m_pChannelVal;
    m_pChannelVal=NULL;
    }

    return TRUE;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::SeekToBegin()
    {
    m_ullSeekPos = 0;
    if(!m_pStreamBuf)
    return FALSE; //SM@100501 sonst Absturz

    m_pStreamBuf->Empty();
    return TRUE;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::Load(void)
    {
    if( m_pSDBase->IsModeRead() && !m_pSDBase->IsModeBuffered() )
    {
    if( !m_pStream ) { ReInitValues(); return FALSE; };

    COleStreamFile *pOleStreamFile = m_pStream->GetOleStreamFile();
    IStream *pStream= m_pStream->GetStream();

    if( !pOleStreamFile ) { ReInitValues(); return FALSE; };

    if( pOleStreamFile->GetPosition( ) >= pOleStreamFile->GetLength( ) ) { ReInitValues(); return FALSE; };

    return iLoad( pOleStreamFile );
    }

    if( m_pSDBase->IsModeRead() && m_pSDBase->IsModeBuffered() )
    {
    if( !m_pStreamBuf ) { ReInitValues(); return FALSE; };

    if( m_pStreamBuf->IsEmpty() )
    {
    if( !m_pSDBase->OpenREx() )
    {
    SetLastSDBError( SDB_SET_COULD_NOT_OPEN_SDB_EXCLUSIVE );

    m_pSDBase->CloseEx();
    return FALSE;
    }

    m_pSDBase->OpenStorages();

    if( !OpenStream() )
    {
    SetLastSDBError( SDB_SET_STREAM_COULD_NOT_BE_OPENED );

    m_pSDBase->CloseEx();
    return FALSE;
    }

    // zum ersten Mal den Buffer füllen
    if( !Fill(m_ullSeekPos,m_ullSize) )
    {
    SetLastSDBError( SDB_SET_STREAM_BUF_COULD_NOT_BE_FILLED );

    m_pSDBase->CloseEx();
    return FALSE;
    }

    m_pSDBase->CloseEx();
    }

    COleStreamFile *pOleStreamFile = m_pStreamBuf->GetOleStreamFile();
    IStream *pStream= m_pStreamBuf->GetStream();

    if( !pOleStreamFile ) { ReInitValues(); return FALSE; };

    // wenn Streamgröße überschritten und Buffer am "Ende"
    if( (m_ullSeekPos >= m_ullSize) && (pOleStreamFile->GetPosition() >= pOleStreamFile->GetLength()) )
    {
    //MK@090102 - Bei reduziertem Kanal würde Wert nach dem Streamende des Kanals gelöscht (damit verfälscht) werden
    //ReInitValues();
    return FALSE;
    }

    // wenn Buffergeöße überschritten
    if( pOleStreamFile->GetPosition( ) >= pOleStreamFile->GetLength( ) )
    {
    // versuchen den Buffer neu einzulesen

    if( !m_pSDBase->OpenREx() )
    {
    SetLastSDBError( SDB_SET_COULD_NOT_OPEN_SDB_EXCLUSIVE );

    m_pSDBase->CloseEx();
    return FALSE;
    }

    m_pSDBase->OpenStorages();

    if( !OpenStream() )
    {
    SetLastSDBError( SDB_SET_COULD_NOT_OPEN_SDB_EXCLUSIVE );

    m_pSDBase->CloseEx();
    return FALSE;
    }

    // Buffer füllen
    if( !Fill(m_ullSeekPos,m_ullSize) )
    {
    SetLastSDBError( SDB_SET_STREAM_BUF_COULD_NOT_BE_FILLED );

    m_pSDBase->CloseEx();
    return FALSE;
    }

    m_pSDBase->CloseEx();

    // !!! // bei fehlschlag -> löschen
    // !!! ReInitValues();
    // !!! return FALSE;
    }

    return iLoad( pOleStreamFile );
    }

    return FALSE;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    HRESULT CSDBStreamDataSet::Flush(void)
    {
    // if( (GetDataType() == STREAM_CHN_DATATYPE_CPLX) ||
    // (GetDataType() == STREAM_CHN_DATATYPE_ARRAY) ||
    // (GetDataType() == STREAM_CHN_DATATYPE_ENUM) ||
    // (GetDataType() == STREAM_CHN_DATATYPE_INTEG) ||
    // (GetDataType() == STREAM_CHN_DATATYPE_CHAR) ||
    // (GetDataType() == STREAM_CHN_DATATYPE_RECORD) ||
    // (GetDataType() == STREAM_CHN_DATATYPE_FREE) )
    // {
    // return CSDBStreamBase::Flush();
    // }

    if( (GetDataType() == STREAM_CHN_DATATYPE_ARRAY) ||
    (GetDataType() == STREAM_CHN_DATATYPE_RECORD) ||
    (GetDataType() == STREAM_CHN_DATATYPE_FREE) )
    {
    return CSDBStreamBase::Flush();
    }

    if( (GetDataType() == STREAM_CHN_DATATYPE_CPLX) )
    {
    long lSize = sVecBuffer_CPLX.size();
    long lByteSize = lSize*SIZE_SET_CPLX;

    BYTE pTemp = new BYTE[lByteSize];
    BYTE     pTemp2 = pTemp;

    for( long l2 =0; l2<lSize; l2++)
    ((sDataSet_CPLX)pTemp2+l2) = sVecBuffer_CPLX[l2];

    CStreamFile pStreamFile = GetStream(); ASSERT(pStreamFile );
    IStream     pStream = pStreamFile->GetStream();ASSERT(pStream);
    ULONG ulWritten;
    pStream->Write( pTemp, lByteSize, &ulWritten );
    pStreamFile->Close();

    //MK@220502
    sVecBuffer_CPLX.clear();
    delete[] pTemp;

    if( ulWritten < lByteSize )
    return 1L;

    }
    else if( (GetDataType() == STREAM_CHN_DATATYPE_REAL) )
    {
    long lSize = sVecBuffer_REAL.size();
    long lByteSize = lSize*SIZE_SET_REAL;

    BYTE pTemp = new BYTE[lByteSize];
    BYTE     pTemp2 = pTemp;

    for( long l2 =0; l2<lSize; l2++)
    ((sDataSet_REAL)pTemp2+l2) = sVecBuffer_REAL[l2];

    CStreamFile pStreamFile = GetStream(); ASSERT(pStreamFile );
    IStream     pStream = pStreamFile->GetStream();ASSERT(pStream);
    ULONG ulWritten;
    pStream->Write( pTemp, lByteSize, &ulWritten );
    pStreamFile->Close();

    //MK@220502
    sVecBuffer_REAL.clear();
    delete[] pTemp;

    if( ulWritten < lByteSize )
    return 1L;
    }
    else if( (GetDataType() == STREAM_CHN_DATATYPE_ENUM) || (GetDataType() == STREAM_CHN_DATATYPE_INTEG) )
    {
    long lSize = sVecBuffer_INTG.size();
    long lByteSize = lSize*SIZE_SET_INTEG;

    BYTE pTemp = new BYTE[lByteSize];
    BYTE     pTemp2 = pTemp;

    for( long l2 =0; l2<lSize; l2++)
    ((sDataSet_INTG)pTemp2+l2) = sVecBuffer_INTG[l2];

    CStreamFile pStreamFile = GetStream(); ASSERT(pStreamFile );
    IStream     pStream = pStreamFile->GetStream();ASSERT(pStream);
    ULONG ulWritten;
    pStream->Write( pTemp, lByteSize, &ulWritten );
    pStreamFile->Close();

    sVecBuffer_INTG.clear();
    delete[] pTemp;

    if( ulWritten < lByteSize )
    return 1L;

    }
    else if( (GetDataType() == STREAM_CHN_DATATYPE_CHAR) )
    {
    long lSize = sVecBuffer_CHAR.size();
    long lByteSize = lSize*SIZE_SET_CHAR;

    BYTE pTemp = new BYTE[lByteSize];
    BYTE     pTemp2 = pTemp;

    for( long l2 =0; l2<lSize; l2++)
    ((sDataSet_CHAR)pTemp2+l2) = sVecBuffer_CHAR[l2];

    CStreamFile pStreamFile = GetStream(); ASSERT(pStreamFile );
    IStream     pStream = pStreamFile->GetStream();ASSERT(pStream);
    ULONG ulWritten;
    pStream->Write( pTemp, lByteSize, &ulWritten );
    pStreamFile->Close();

    //MK@220502
    sVecBuffer_CHAR.clear();
    delete[] pTemp;

    if( ulWritten < lByteSize )
    return 1L;
    }
    else
    ASSERT(FALSE);

    return 0L;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //MK@130502
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CSDBStreamDataSet::Set( long lChannelValSize, BYTE* pChannelVal, long lID )
    {
    //MK@170502
    ASSERT( (m_lDataType == STREAM_CHN_DATATYPE_ARRAY) ||
    (m_lDataType == STREAM_CHN_DATATYPE_RECORD) ||
    (m_lDataType == STREAM_CHN_DATATYPE_FREE) );

    // if( m_pChannelVal )
    // delete[] m_pChannelVal;
    //
    // if( lChannelValSize )
    // {
    // m_pChannelVal = new BYTE[lChannelValSize];
    // memcpy( m_pChannelVal, pChannelVal, lChannelValSize );
    // m_lChannelValSize = lChannelValSize;
    // m_lID = lID;
    // }
    // else
    // {
    // m_pChannelVal = pChannelVal;
    // m_lChannelValSize = lChannelValSize;
    // m_lID = lID;
    // }

    if( *m_ppChannelVal )
    delete[] *m_ppChannelVal;

    if( lChannelValSize )
    {
    *m_ppChannelVal = new BYTE[lChannelValSize];
    memcpy( *m_ppChannelVal, pChannelVal, lChannelValSize );
    m_lChannelValSize = lChannelValSize;
    *m_plID = lID;
    }
    else
    {
    *m_ppChannelVal = pChannelVal;
    m_lChannelValSize = lChannelValSize;
    *m_plID = lID;
    }

    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //MK@270502 Wunsch TSF - Anzahl der Stützstellen ermitteln
    // - enthält aber wg. des schnellen Automatismus auch die Stützstellen mit ID=0 (eigentlich gelöscht!)
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    long CSDBStreamDataSet::GetNumberOfEntries()
    {
    if( !m_pSDBase ) { ASSERT( m_pSDBase ); return 0; }

    if( !m_pSDBase->OpenREx() )
    {
    ASSERT(FALSE);
    m_pSDBase->CloseEx();
    return 0;
    }

    CSDBStorage *pStorage = m_pSDBase->GetStorageDataSet();

    if( !pStorage ) { ASSERT(FALSE); m_pSDBase->CloseEx(); return 0; };

    if( OpenStreamFile( pStorage->GetStorage() ) )
    {
    ULARGE_INTEGER ulStreamSize = m_pStream->GetSize();
    long lEntrySize = GetSizeOfEntry();

    if( lEntrySize == 0 ) { ASSERT(FALSE); m_pSDBase->CloseEx(); return 0; }

    long lNumberOfEntries = ulStreamSize.QuadPart / lEntrySize;

    ASSERT( !(ulStreamSize.QuadPart % lEntrySize) );

    m_pSDBase->CloseEx();

    return lNumberOfEntries;
    }

    m_pSDBase->CloseEx();

    return 0;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //MK@270502 Berechnet anhand des zugewiesenen Datentyps und evtl. der Member die Größe eines DataSets
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    long CSDBStreamDataSet::GetSizeOfEntry()
    {
    long lSizeOfEntry=0;

    switch( m_lDataType )
    {
    case STREAM_CHN_DATATYPE_REAL: lSizeOfEntry = SIZE_SET_REAL;
    break;
    case STREAM_CHN_DATATYPE_CPLX: lSizeOfEntry = SIZE_SET_CPLX;
    break;
    case STREAM_CHN_DATATYPE_CHAR: lSizeOfEntry = SIZE_SET_CHAR;
    break;
    case STREAM_CHN_DATATYPE_INTEG:
    case STREAM_CHN_DATATYPE_ENUM: lSizeOfEntry = SIZE_SET_INTEG;
    break;
    case STREAM_CHN_DATATYPE_FREE:
    case STREAM_CHN_DATATYPE_ARRAY:
    case STREAM_CHN_DATATYPE_RECORD: // Wenn ChannelValSize == 0 dann wahrscheinlich Größe zu setzen vergessen
    if( !m_lChannelValSize )
    ASSERT(FALSE);
    lSizeOfEntry = m_lChannelValSize + SIZEOF_LONG;
    break;

    default: ASSERT(FALSE);
    break;
    }

    ASSERT(lSizeOfEntry);

    return lSizeOfEntry;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CSDBStreamDataSet::EmptyWriteBufferTemporary()
    {
    if( GetDataType() == STREAM_CHN_DATATYPE_REAL )
    {
    sVecBuffer_REAL.clear();
    }
    else if( GetDataType() == STREAM_CHN_DATATYPE_CPLX )
    {
    sVecBuffer_CPLX.clear();
    }
    else if( (GetDataType() == STREAM_CHN_DATATYPE_INTEG) || (GetDataType() == STREAM_CHN_DATATYPE_ENUM) )
    {
    sVecBuffer_INTG.clear();
    }
    else if( GetDataType() == STREAM_CHN_DATATYPE_CHAR )
    {
    sVecBuffer_CHAR.clear();
    }
    else
    EmptyReadBufferTemporary();
    }

    #include "Compare_DataTypes.h"
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Store_MK@080102
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::Store_Reduce()
    {
    // wenn max. Größe des Write-Puffers eines DataSet-Streams überschritten
    // --> alles in die SDB flushen
    if( ((sVecBuffer_REAL.size()*SIZE_SET_REAL) > _MAX_SET_BUF_SIZE_WRITE)
    //||
    //((sVecBuffer_CPLX.size()*SIZE_SET_CPLX) > _MAX_SET_BUF_SIZE_WRITE)
    )
    {
    m_pSDBase->Flush();
    }

    try
    {
    switch( m_lDataType )
    {
    case STREAM_CHN_DATATYPE_REAL :
    {
    if( !sVecBuffer_REAL.size() )
    {
    sVecBuffer_REAL.push_back( m_sDataSet_REAL );
    }
    else if( !Compare_REAL_ForEquality( sVecBuffer_REAL.back().dRealVal, m_sDataSet_REAL.dRealVal ) )
    {
    sVecBuffer_REAL.push_back( m_sDataSet_REAL );
    }
    break;
    }
    case STREAM_CHN_DATATYPE_CPLX :
    {
    if( !sVecBuffer_CPLX.size() )
    {
    sVecBuffer_CPLX.push_back( m_sDataSet_CPLX );
    }
    else if( !Compare_CPLX_ForEquality( sVecBuffer_CPLX.back().dRealVal, sVecBuffer_CPLX.back().dImagVal, m_sDataSet_CPLX.dRealVal, m_sDataSet_CPLX.dImagVal ) )
    {
    sVecBuffer_CPLX.push_back( m_sDataSet_CPLX );
    }
    break;
    }
    case STREAM_CHN_DATATYPE_ENUM :
    case STREAM_CHN_DATATYPE_INTEG :
    {
    if( !sVecBuffer_INTG.size() )
    {
    sVecBuffer_INTG.push_back( m_sDataSet_INTG );
    }
    else if( !Compare_INTG_ForEquality( sVecBuffer_INTG.back().iIntegVal, m_sDataSet_INTG.iIntegVal) )
    {
    sVecBuffer_INTG.push_back( m_sDataSet_INTG );
    }
    break;
    }
    case STREAM_CHN_DATATYPE_CHAR :
    {
    if( !sVecBuffer_CHAR.size() )
    {
    sVecBuffer_CHAR.push_back( m_sDataSet_CHAR );
    }
    else if( !Compare_CHAR_ForEquality( sVecBuffer_CHAR.back().cCharVal, m_sDataSet_CHAR.cCharVal ) )
    {
    sVecBuffer_CHAR.push_back( m_sDataSet_CHAR );
    }
    break;
    }
    case STREAM_CHN_DATATYPE_FREE :
    case STREAM_CHN_DATATYPE_ARRAY :
    case STREAM_CHN_DATATYPE_RECORD :
    {
    if( !m_pChannelVal )
    {
    COleStreamFile *pOleStreamFile = m_pStreamBuf->GetOleStreamFile();
    pOleStreamFile->SeekToEnd();

    if( m_lChannelValSize )
    pOleStreamFile->Write( *m_ppChannelVal, m_lChannelValSize );

    pOleStreamFile->Write( m_plID, sizeof(long) );

    m_pChannelVal = new BYTE[m_lChannelValSize];

    memcpy( m_pChannelVal, *m_ppChannelVal, m_lChannelValSize );
    }
    else if( !Compare_FREE_ForEquality( m_pChannelVal, *m_ppChannelVal, m_lChannelValSize ) )
    {
    COleStreamFile *pOleStreamFile = m_pStreamBuf->GetOleStreamFile();
    pOleStreamFile->SeekToEnd();

    if( m_lChannelValSize )
    pOleStreamFile->Write( *m_ppChannelVal, m_lChannelValSize );

    pOleStreamFile->Write( m_plID, sizeof(long) );
    memcpy( m_pChannelVal, *m_ppChannelVal, m_lChannelValSize );
    }

    break;
    }
    }

    return TRUE;
    }
    catch(...)
    {
    SetLastSDBError( SDB_SET_STREAM_COULD_NOT_STORE );
    return FALSE;
    }

    return TRUE;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CSDBStreamDataSet::Load_Reduce( long lID )
    {
    //
    if( m_pSDBase->IsModeRead() && m_pSDBase->IsModeBuffered() )

    try
    {
    //CArchive arc(pOleStreamFile, CArchive::load);

    switch( m_lDataType )
    {
    case STREAM_CHN_DATATYPE_REAL :
    {
    //pOleStreamFile->Read( &m_dRealVal, sizeof(double) );

    sDataSet_REAL* p1 = (sDataSet_REAL*)m_pReadBuffer->GetBuffer( lID );

    if( !p1 )
    return TRUE;

    long lSeekPosInBuffer=0;

    while( lSeekPosInBuffer<m_pReadBuffer->GetNumberOfEntriesInBuffer() )
    {
    if( p1[lSeekPosInBuffer].lID == lID )
    {
    m_sDataSet_REAL = p1[lSeekPosInBuffer];
    return TRUE;
    }
    else if( p1[lSeekPosInBuffer].lID > lID )
    {
    m_sDataSet_REAL = p1[lSeekPosInBuffer-1];
    return TRUE;
    }

    lSeekPosInBuffer++;
    }

    break;
    }

    case STREAM_CHN_DATATYPE_CPLX :
    {
    //pOleStreamFile->Read( &m_dRealVal, sizeof(double) );
    //pOleStreamFile->Read( &m_dImagVal, sizeof(double) );

    sDataSet_CPLX* p1 = (sDataSet_CPLX*)m_pReadBuffer->GetBuffer( lID );

    if( !p1 )
    return TRUE;

    long lSeekPosInBuffer=0;

    while( lSeekPosInBuffer<m_pReadBuffer->GetNumberOfEntriesInBuffer() )
    {
    if( p1[lSeekPosInBuffer].lID == lID )
    {
    m_sDataSet_CPLX = p1[lSeekPosInBuffer];
    return TRUE;
    }
    else if( p1[lSeekPosInBuffer].lID > lID )
    {
    m_sDataSet_CPLX = p1[lSeekPosInBuffer-1];
    return TRUE;
    }

    lSeekPosInBuffer++;
    }

    // sonst wird das letzte benutzt
    break;
    }
    case STREAM_CHN_DATATYPE_FREE:
    case STREAM_CHN_DATATYPE_ARRAY:
    case STREAM_CHN_DATATYPE_RECORD:
    {
    BYTE* p1 = (BYTE*)m_pReadBuffer->GetBuffer( lID );

    if( !p1 )
    return TRUE;

    long lSeekPosInBuffer=0;

    while( lSeekPosInBuffer<m_pReadBuffer->GetNumberOfEntriesInBuffer() )
    {
    if( (long)(p1+lSeekPosInBufferGetSizeOfEntry()+m_lChannelValSize) == lID )
    {
    m_sDataSet_FREE.lID = (long)(p1+lSeekPosInBuffer    GetSizeOfEntry()+m_lChannelValSize);

    // Speicher reservieren
    if( m_sDataSet_FREE.m_pChannelVal )
    {
    delete[] m_sDataSet_FREE.m_pChannelVal;
    m_sDataSet_FREE.m_pChannelVal = NULL;
    }

    if( m_lChannelValSize )
    {
    m_sDataSet_FREE.m_pChannelVal = new BYTE[m_lChannelValSize];
    }
    else
    m_sDataSet_FREE.m_pChannelVal = NULL;

    memcpy( m_sDataSet_FREE.m_pChannelVal, (BYTE*)(p1+lSeekPosInBufferGetSizeOfEntry()), m_lChannelValSize );
    //m_sDataSet_FREE = p1[lSeekPosInBuffer];
    return TRUE;
    }
    else if( (long)(p1+lSeekPosInBuffer    GetSizeOfEntry()+m_lChannelValSize) > lID )
    {
    m_sDataSet_FREE.lID = (long)(p1+(lSeekPosInBuffer-1)*GetSizeOfEntry()+m_lChannelValSize);

    // Speicher reservieren
    if( m_sDataSet_FREE.m_pChannelVal )
    {
    delete[] m_sDataSet_FREE.m_pChannelVal;
    m_sDataSet_FREE.m_pChannelVal = NULL;
    }

    if( m_lChannelValSize )
    {
    m_sDataSet_FREE.m_pChannelVal = new BYTE[m_lChannelValSize];
    }
    else
    m_sDataSet_FREE.m_pChannelVal = NULL;

    memcpy( m_sDataSet_FREE.m_pChannelVal, (BYTE*)(p1+(lSeekPosInBuffer-1)*GetSizeOfEntry()), m_lChannelValSize );
    //m_sDataSet_FREE = p1[lSeekPosInBuffer-1];
    return TRUE;
    }

    lSeekPosInBuffer++;
    }
    break;
    }
    case STREAM_CHN_DATATYPE_ENUM:
    case STREAM_CHN_DATATYPE_INTEG:
    {
    sDataSet_INTG* p1 = (sDataSet_INTG*)m_pReadBuffer->GetBuffer( lID );

    if( !p1 )
    return TRUE;

    long lSeekPosInBuffer=0;

    while( lSeekPosInBuffer<m_pReadBuffer->GetNumberOfEntriesInBuffer() )
    {
    if( p1[lSeekPosInBuffer].lID == lID )
    {
    m_sDataSet_INTG = p1[lSeekPosInBuffer];
    return TRUE;
    }
    else if( p1[lSeekPosInBuffer].lID > lID )
    {
    m_sDataSet_INTG = p1[lSeekPosInBuffer-1];
    return TRUE;
    }

    lSeekPosInBuffer++;
    }

    break;
    }
    case STREAM_CHN_DATATYPE_CHAR:
    {
    sDataSet_CHAR* p1 = (sDataSet_CHAR*)m_pReadBuffer->GetBuffer( lID );

    if( !p1 )
    return TRUE;

    long lSeekPosInBuffer=0;

    while( lSeekPosInBuffer<m_pReadBuffer->GetNumberOfEntriesInBuffer() )
    {
    if( p1[lSeekPosInBuffer].lID == lID )
    {
    m_sDataSet_CHAR = p1[lSeekPosInBuffer];
    return TRUE;
    }
    else if( p1[lSeekPosInBuffer].lID > lID )
    {
    m_sDataSet_CHAR = p1[lSeekPosInBuffer-1];
    return TRUE;
    }

    lSeekPosInBuffer++;
    }
    // sonst wird das letzte benutzt
    break;
    }
    }
    }
    catch(...)
    {
    SetLastSDBError( SDB_EXP_STREAM_COULD_NOT_LOAD );
    ReInitValues();
    return FALSE;
    }

    return TRUE;
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////
    //BOOL CSDBStreamDataSet::Fill2(ULONGLONG &ullSeekPos, ULONGLONG &ullSize)
    //{
    // if( !m_pStreamBuf || !m_pStream ) return FALSE;
    //
    // ULARGE_INTEGER uliSize = m_pStream->GetSize();
    // ullSize = uliSize.QuadPart;
    //
    // if( !uliSize.QuadPart ) return FALSE;
    //
    // LARGE_INTEGER li1, li2;
    // li1.QuadPart = (ULONGLONG)0;
    //
    // li2.QuadPart = ullSeekPos;
    //
    // uliSize.QuadPart = uliSize.QuadPart - ullSeekPos;
    //
    // if( uliSize.QuadPart > m_lMaxNumberOfEntriesInBuffer )
    // {
    // uliSize.QuadPart = m_lMaxNumberOfEntriesInBuffer;
    // }
    //
    // if( uliSize.QuadPart < m_lMaxNumberOfEntriesInBuffer )
    // {
    // //m_pStreamBuf->Empty();
    // m_lLastPosInBuffer = uliSize.QuadPart / GetSizeOfEntry();
    // }
    //
    // HRESULT hRes;
    //
    // //IStream *pStreamBuf = m_pStreamBuf->GetStream();
    // IStream pStream = m_pStream->GetStream();
    //
    // //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx beide Streams positionieren xx
    //
    // //hRes = pStreamBuf->Seek ( li1, STREAM_SEEK_SET, NULL ); //&uli1 );
    // hRes = pStream->Seek ( li2, STREAM_SEEK_SET, NULL ); //&uli1 );
    //
    // //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Eigentliche Copy-Operation xx
    //
    // //pStream->CopyTo( pStreamBuf, uliSize, NULL, NULL );
    //
    // ULONG ulBytesRead;
    // ULONG ulSize = uliSize.QuadPart;
    // pStream->Read( (BYTE    )pBuffer+m_lFirstPosInBuffer2, ulSize, &ulBytesRead );
    //
    // //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ZielStream schliessen xx
    //
    // hRes = pStream->Seek( li1, STREAM_SEEK_CUR, &uliSize );
    //
    // ullSeekPos = uliSize.QuadPart;
    //
    // m_pStream->Close();
    //
    // //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Buffer auf Größe NULL setzen xx
    //
    // ULARGE_INTEGER uli2;
    // uli2.QuadPart = (ULONGLONG)0;
    //
    // //hRes = pStreamBuf->Seek ( li1, STREAM_SEEK_SET, NULL );
    //
    //#ifdef TRACE_DEBUG_
    // TRACE("Fill\r\n");
    //#endif //TRACE_DEBUG_
    //
    // return TRUE;
    //}

    Aber normal arbeite ich überhaupt nicht mit der Datei, die ist nirgends eingebunden!!! Das ist das Problem, das Programm braucht die Datei gar nicht!!!

    0
  • H

    Ach so, dein Betriebssystem will uns nur verscheißern indem es beim Absturz diese Datei angibt mit Zeile... ach so....

    Das wird ja immer besser hier... habt ihr noch'n Stuhl frei? Ich hab Popcorn mit... 😃 😃 😃

    0
  • S

    ach ihr kapiert das nicht

    0
  • K

    Hi!

    @sonnenschein1984

    Diese Datei wird schon duch dein Programm benutzt, w*****einlich durch eine drittkomponente. Du nutzt eine Funktion von dort und irgendwelche Parameter könnten nicht stimmen oder sonstwas. Die Informationen sind leider nicht ausreichend um Dir zu helfen.

    Mit Hilfe des Debuggers kannst Du Dich der Funktion nähern die in Deinem Eigenen Quellcode aufgerufen wird um zur Debug Assertion zu kommen.

    Das Posten der cpp kann helfen, unter 2 Bedinnungen.

    1. CodeTags (Wenn Du Antwortest findest Du links neber den Smilies den Knopf auf dem blau C++ Code steht - klick mal drauf!)

    2. mal eine Makierung wo Zeile 179 ist. Hier fängt sicherlich NIEMAND an zu zählen...

    0
Anmelden zum Antworten