Fehlermeldung

[sonnenschein1984]

#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+lSeekPosInBufferGetSizeOfEntry()+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+lSeekPosInBufferGetSizeOfEntry()+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!!!

[Hepi]

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...

[sonnenschein1984]

ach ihr kapiert das nicht

[Knuddlbaer]

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...

[MFK]

Original erstellt von sonnenschein1984:
ach ihr kapiert das nicht

Ach so ist das?
Ich denke, hier sind sich fast alle einig, wer hier 'ne Schnallbremse hat.

Übrigens:

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;

[dEUs]

mir wirds hier zu blöd. ihc komm mir verscheissert vor!

[Hepi]

Boah, ich dachte schon die CODETAGS sind hier im Thread kaputt... Gottseidank gehen sie noch....

[sonnenschein1984]

danke an Knuddelbär du warst der Erste der mir hier eine ordentliche Antwort gegeben hat. Daraus konnte man sich wenigstens etwas nehmen, weil du es verständlich erklärt hast, die Anderen sind nur immer am rummeckern. Die haben hier wahrscheinlich alle super mega viel Erfahrungen, aber ich hab erst angefangen und muß das jetzt beruflich machen und da ist man eigentlich froh wenn man jemand findet der einem hilft, doch hier wird man immer nur dumm angemacht. Das ist echt ätzend.!!!

Ich danke dir das du mir wenigstens ein bißchen weitergeholfen hast!!!

[dEUs]

Man weisst dich dreimal? viermal? darauf hin, dass du diese verdammte Zeile mit CODETAGS posten sollst! Und du postest uns irgeneine komplette Datei OHNE Codetags! Wenn man nicht weiss, was CodeTags sind, dann bemüht man die Suche, liest den Text, der hier im MFC-Forum über den Threads steht oder ruft bei der Auskunft an, man macht aber nicht die Leute blöd an, die versuchen einem zu helfen, was leider aber aufgrund deines unvermögens unmöglich ist!
Ich hoffe, das war deutlich!

[Hepi]

...dabei hat Knuddlbaer nicht mal großartig was anderes gesagt als wir alle:

- Benutze endlich CodeTags
- Zeig uns den Quelltext mit Zeile 729

Du hingegen hast immer gesagt:
- Ihr versteht das nicht
- Mein Programm braucht diese Datei nicht

usw.

Keine gute Attitüde, wenn man Hilfe braucht, das sag ich Dir mal so....

[sonnenschein1984]

ihr habt es einfach nicht drauf jemand der neu anfängt zu helfen, dass habe ich schon bei vielen Einträgen hier bemerkt

[dEUs]

Soso. Verrate mir doch bitte, was wir falsch machen.

[sonnenschein1984]

Komisch das andere helfen können nur ihr nicht!!!

Und das ist nicht nur unter dieser Rubrik so, sondern unter den Anderen genauso!!!

Alle die neu anfangen sind bei euch wahrscheinlich Dummies, die es nicht drauf haben, aber ihr seit die Chefs, ja klar

[Hepi]

Freundchen, zum letzten Mal:

Gib uns die nötigen Informationen, dann kann man Dir auch vernünftig helfen!
Du hast noch immer nicht die gewünschte Datei (ja genau die in der er abschmiert) gepostet!

Sollen wir etwa die Infos aus den Fingern saugen???

Ich fass es nicht....

[sonnenschein1984]

außerdem woher soll ich wissen, dass die Datei vielleicht als noch eine Komponente irgendwo benutzt wird, wenn ich sie nie irgendwo eingebunden habe, sowas kann man ja mal sagen! Wenigstens einen kleinen Tipp an Neuanfänger geben, aber sowas kennt ihr nicht

[dEUs]

Guck, du liest schon wieder nicht, du kackst nur blöd rum. Sag uns doch, was wir beim Helfen falsch machen.

[MFK]

Original erstellt von sonnenschein1984:
**doch hier wird man immer nur dumm angemacht. Das ist echt ätzend.!!!

Ich danke dir das du mir wenigstens ein bißchen weitergeholfen hast!!!**

Meine Güte! Lass mal dein Realitätsmodul prüfen!

Die Fehlermeldung liefert dir schon einen Dateinamen und eine Zeilennummer. Da könnte man ja durchaus mal auf die Idee kommen, in dieser Datei an der angegebenen Stelle nachzuschauen. Und siehe da, da steht sogar in einem netten Kommentar eine mögliche Ursache für die Assertion. Hätte man drauf kommen können.
Aber lassen wir lieber die anderen die Arbeit machen, und uns alles einzeln aus der Nase ziehen. Und bloß keine Code-Tags verwenden, man liefe ja Gefahr, den Quellcode lesen zu können.

Und wenn man dann, wenn du zum vierten Mal den falschen Code ohne Code-Tags zeigst, nicht mehr ganz so freundlich ist, dann ist das "ätzend".

[Hepi]

Original erstellt von sonnenschein1984:
außerdem woher soll ich wissen, dass die Datei vielleicht als noch eine Komponente irgendwo benutzt wird, wenn ich sie nie irgendwo eingebunden habe, sowas kann man ja mal sagen! Wenigstens einen kleinen Tipp an Neuanfänger geben, aber sowas kennt ihr nicht

Weil Dein Debugger es Dir gesagt hat in einer Fehlermeldung, die Du uns sogar (nach mehrmaligem Nachfragen) sogar gezeigt hattest!!!

[dEUs]

Deine Debugmeldung sagt dir, dass er in dieser Datei in dieser Zeile abgestürzt ist. Wieso sollte er die Datei denn dann nciht verwenden???

[sonnenschein1984]

ich laß es bei euch sein, meine Informationen versuche ich mir jetzt von anderen zu beziehen, welchen die mir wahrscheinlich eher helfen können