Fehlermeldung

goochie

@ sonnenschein

genau das Gleiche war doch Gestern schonmal. Wie soll man euch helfen, wenn Ihr nichtmal euer Problem beschreibt !!

sonnenschein1984

gestern war es ein anderes. Und das ist raus.

hier mein Code:

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());
   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();

}

//Main-Function
void main()
{
   int auswahl;
   cout<<"Filename: ";
   cin.get (filename,80);
   cout<<"Datei oeffnen......1"<<endl;
   cout<<"Datei schliessen...2"<<endl;
   cout<<"Datei auslesen.....3"<<endl;
   cout<<"Beenden............4"<<endl;
   cout<<"Ihre Auswahl:";
   cin>>auswahl;

   switch (auswahl)
   {
      case 1: open();break;
      case 2: close();break;
      case 3: auslesen();break;
      case 4: break;
      default: cout<<"Error"<<endl;
   }
}

Und wenn ich dann eine *.exe erstelle, kann ich noch den Filenamen eingeben, dann kann ich noch auf "Datei auslesen" gehen und dann bringt es mir den beschriebenen Fehler, was soll ich da mehr beschreiben??

CODE TAGS BENUTZEN

[ Dieser Beitrag wurde am 19.06.2003 um 08:23 Uhr von C-O-M-M-A-N-D-E-R editiert. ]

Hepi

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

Dafür sind Debugger da!

sonnenschein1984

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

sonnenschein1984

kann mir den niemand helfen??

MFK

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

sonnenschein1984

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

MFK

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?

sonnenschein1984

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

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

MFK

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

sonnenschein1984

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

dEUs

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

MFK

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!

sonnenschein1984

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();

}

MFK

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

dEUs

sonnenschein, es ist extrem unspassig dir zu helfen!!

Hepi

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

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