/*
========================
idSoundSample_XAudio2::MakeDefault
========================
*/
void idSoundSample_XAudio2::MakeDefault()
{
FreeData();
static const int DEFAULT_NUM_SAMPLES = 256;
timestamp = FILE_NOT_FOUND_TIMESTAMP;
loaded = true;
memset( &format, 0, sizeof( format ) );
format.basic.formatTag = idWaveFile::FORMAT_PCM;
format.basic.numChannels = 1;
format.basic.bitsPerSample = 16;
format.basic.samplesPerSec = XAUDIO2_MIN_SAMPLE_RATE;
format.basic.blockSize = format.basic.numChannels * format.basic.bitsPerSample / 8;
format.basic.avgBytesPerSec = format.basic.samplesPerSec * format.basic.blockSize;
assert( format.basic.blockSize == 2 );
totalBufferSize = DEFAULT_NUM_SAMPLES * 2;
short* defaultBuffer = ( short* )AllocBuffer( totalBufferSize, GetName() );
for( int i = 0; i < DEFAULT_NUM_SAMPLES; i += 2 )
{
defaultBuffer[i + 0] = SHRT_MIN;
defaultBuffer[i + 1] = SHRT_MAX;
}
buffers.SetNum( 1 );
buffers[0].buffer = defaultBuffer;
buffers[0].bufferSize = totalBufferSize;
buffers[0].numSamples = DEFAULT_NUM_SAMPLES;
buffers[0].buffer = GPU_CONVERT_CPU_TO_CPU_CACHED_READONLY_ADDRESS( buffers[0].buffer );
playBegin = 0;
playLength = DEFAULT_NUM_SAMPLES;
}
void emDirEntry::Clear()
{
if (!--Data->RefCount) FreeData();
Data=&EmptyData;
}
SplineData::~SplineData()
{
FreeData();
}
~MMDeviceAudioSource()
{
StopCapture();
FreeData();
SafeRelease(mmEnumerator);
}
Player::~Player()
{
FreeData();
}
/*
================
idProgram::~idProgram
================
*/
idProgram::~idProgram()
{
FreeData();
}
void AllocData()
{
FreeData();
m_pKVData = new KeyValues( "gamestats" );
}
Program::~Program()
{
FreeData();
}
DataNode::~DataNode()
{
FreeData();
}
void InitEns (enkf_struct ens)
{
int ne;
pihm_struct pihm;
N_Vector CV_Y; /* State Variables Vector */
int nsv;
int i, j;
char outputdir[MAXSTRING];
outputdir[0] = '\0';
pihm = (pihm_struct)malloc (sizeof *pihm);
ReadAlloc (project, pihm);
/* problem size */
nsv = 3 * pihm->numele + 2 * pihm->numriv;
CV_Y = N_VNew_Serial (nsv);
Initialize (pihm, CV_Y);
MapOutput (project, pihm, outputdir);
ens->numele = pihm->numele;
ens->numriv = pihm->numriv;
ens->ascii = pihm->ctrl.ascii;
/* Initialize ensemble members */
ne = ens->ne;
ens->member = (ensmbr_struct *) malloc (ne * sizeof (ensmbr_struct));
/*
* Define variable controls: vairable names, variable dimension, etc.
*/
MapVar (ens->var, ens->numele, ens->numriv);
InitOper (pihm, ens);
printf("Ensemble members: %d\n", ne);
printf("Default observation cycle: %-d hour(s)\n", ens->interval / 3600);
printf("Observations:");
if (ens->nobs == 0)
{
printf(" none");
}
else
{
for (i = 0; i < ens->nobs - 1; i++)
{
printf(" %s,", ens->obs[i].name);
}
printf(" %s\n", ens->obs[ens->nobs - 1].name);
}
for (i = 0; i < ne; i++)
{
for (j = 0; j < MAXVAR; j++)
{
if (ens->var[j].dim > 0)
{
ens->member[i].var[j] =
(double *) malloc (ens->var[j].dim * sizeof(double));
}
}
}
N_VDestroy_Serial (CV_Y);
FreeData (pihm);
free (pihm);
}
// Like ReloadStrings, but clears all the strings before reloading
void FStringTable::ResetStrings ()
{
FreeData ();
LoadStrings (LumpNum, -1, false);
}
otG711Encoder::~otG711Encoder()
{
FreeData();
}
/**
* Loads elevation from a USGS DEM file.
*
* Some non-standard variations of the DEM format are supported.
*
* You should call SetupLocalCS() after loading if you will be doing
* heightfield operations on this grid.
*
* \returns \c true if the file was successfully opened and read.
*/
bool vtElevationGrid::LoadFromDEM(const char *szFileName,
bool progress_callback(int), vtElevError *err)
{
// Free buffers to prepare to receive new data
FreeData();
if (progress_callback != NULL) progress_callback(0);
FILE *fp = vtFileOpen(szFileName,"rb");
if (!fp) // Cannot Open File
{
SetError(err, vtElevError::FILE_OPEN, "Couldn't open file '%s'", szFileName);
return false;
}
// check for version of DEM format
int iRow, iColumn;
char buffer[158];
fseek(fp, 864, 0);
if (fread(buffer, 144, 1, fp) != 1)
{
SetError(err, vtElevError::READ_DATA, "Couldn't read DEM data from '%s'", szFileName);
return false;
}
bool bOldFormat = (strncmp(buffer, " 1 1", 12) == 0);
bool bNewFormat = false;
bool bFixedLength = true;
int iDataStartOffset = 1024; // set here to avoid compiler warning
int i, j;
if (bOldFormat)
iDataStartOffset = 1024; // 1024 is record length
else
{
fseek(fp, 1024, 0); // Check for New Format
IConvert(fp, 6, iRow);
IConvert(fp, 6, iColumn);
if (iRow==1 && iColumn==1) // File OK?
{
bNewFormat = true;
iDataStartOffset = 1024;
}
else
{
// might be the Non-fixed-length record format
// Record B can start anywhere from 865 to 1023
// Record B is identified by starting with the row/column
// of its first profile, " 1 1"
fseek(fp, 865, 0);
if (fread(buffer, 158, 1, fp) != 1)
{
SetError(err, vtElevError::READ_DATA, "Couldn't read DEM data from '%s'", szFileName);
fclose(fp);
return false;
}
for (i = 0; i < 158-12; i++)
{
if (!strncmp(buffer+i, " 1 1", 12))
{
// Found it
bFixedLength = false;
iDataStartOffset = 865+i;
break;
}
}
if (i == 158-12)
{
// Not a DEM file
SetError(err, vtElevError::READ_DATA, "Couldn't read DEM data from '%s'", szFileName);
fclose(fp);
return false;
}
}
}
// Read the embedded DEM name
char szName[41];
fseek(fp, 0, 0);
if (fgets(szName, 41, fp) == NULL)
return false;
int len = strlen(szName); // trim trailing whitespace
while (len > 0 && szName[len-1] == ' ')
{
szName[len-1] = 0;
len--;
}
m_strOriginalDEMName = szName;
fseek(fp, 156, 0);
int iCoordSystem, iUTMZone;
IConvert(fp, 6, iCoordSystem);
IConvert(fp, 6, iUTMZone);
fseek(fp, 168, 0);
double dProjParams[15];
for (i = 0; i < 15; i++)
{
if (!DConvert(fp, 24, dProjParams[i], DEBUG_DEM))
return false;
}
int iDatum = EPSG_DATUM_NAD27; // default
// OLD format header ends at byte 864 (0x360); new format has Datum
if (bNewFormat)
{
// year of data compilation
char szDateBuffer[5];
fseek(fp, 876, 0); // 0x36C
if (fread(szDateBuffer, 4, 1, fp) != 1)
return false;
szDateBuffer[4] = 0;
// Horizontal datum
// 1=North American Datum 1927 (NAD 27)
// 2=World Geodetic System 1972 (WGS 72)
// 3=WGS 84
// 4=NAD 83
// 5=Old Hawaii Datum
// 6=Puerto Rico Datum
fseek(fp, 890, 0); // 0x37A
int datum;
IConvert(fp, 2, datum);
VTLOG("DEM Reader: Read Datum Value %d\n", datum);
switch (datum)
{
case 1: iDatum = EPSG_DATUM_NAD27; break;
case 2: iDatum = EPSG_DATUM_WGS72; break;
case 3: iDatum = EPSG_DATUM_WGS84; break;
case 4: iDatum = EPSG_DATUM_NAD83; break;
case 5: iDatum = EPSG_DATUM_OLD_HAWAIIAN; break;
case 6: iDatum = EPSG_DATUM_PUERTO_RICO; break;
}
}
fseek(fp, 528, 0);
int iGUnit, iVUnit;
IConvert(fp, 6, iGUnit);
IConvert(fp, 6, iVUnit);
// Ground (Horizontal) Units in meters
double fGMeters;
switch (iGUnit)
{
case 0: fGMeters = 1.0; break; // 0 = radians (never encountered)
case 1: fGMeters = 0.3048; break; // 1 = feet
case 2: fGMeters = 1.0; break; // 2 = meters
case 3: fGMeters = 30.922; break; // 3 = arc-seconds
}
// Vertical Units in meters
double fVertUnits;
switch (iVUnit)
{
case 1: fVertUnits = 0.3048; break; // feet to meter conversion
case 2: fVertUnits = 1.0; break; // meters == meters
default: fVertUnits = 1.0; break; // anything else, assume meters
}
fseek(fp, 816, 0);
double dxdelta, dydelta, dzdelta;
DConvert(fp, 12, dxdelta, DEBUG_DEM); // dxdelta (unused)
DConvert(fp, 12, dydelta, DEBUG_DEM);
DConvert(fp, 12, dzdelta, DEBUG_DEM);
m_bFloatMode = false;
// Read the coordinates of the 4 corners
VTLOG("DEM corners:\n");
DPoint2 corners[4]; // SW, NW, NE, SE
fseek(fp, 546, 0);
for (i = 0; i < 4; i++)
{
DConvert(fp, 24, corners[i].x, DEBUG_DEM);
DConvert(fp, 24, corners[i].y, DEBUG_DEM);
}
for (i = 0; i < 4; i++)
VTLOG(" (%lf, %lf)", corners[i].x, corners[i].y);
VTLOG("\n");
// Set up the projection and corners
bool bGeographic = (iCoordSystem == 0);
if (bGeographic)
{
for (i = 0; i < 4; i++)
{
// convert arcseconds to degrees
m_Corners[i].x = corners[i].x / 3600.0;
m_Corners[i].y = corners[i].y / 3600.0;
}
}
else
{
// some linear coordinate system
for (i = 0; i < 4; i++)
m_Corners[i] = corners[i];
}
// Special case. Some old DEMs claim to be NAD27, but they are of Hawai'i,
// and Hawai'i has no NAD27, it is actually OHD.
if (iDatum == EPSG_DATUM_NAD27)
{
DRECT Hawaii(0,0,0,0);
if (bGeographic)
Hawaii.SetRect(-164, 24, -152, 17);
else if (iCoordSystem == 1) // UTM
{
if (iUTMZone == 4)
Hawaii.SetRect(240000, 2600000, 1000000, 2000000);
else if (iUTMZone == 5)
Hawaii.SetRect(-400000, 2600000, 400000, 2000000);
}
for (i = 0; i < 4; i++)
{
if (Hawaii.ContainsPoint(m_Corners[i]))
iDatum = EPSG_DATUM_OLD_HAWAIIAN;
}
}
bool bSuccessfulCRS = true;
switch (iCoordSystem)
{
case 0: // geographic (lat-lon)
iUTMZone = -1;
bSuccessfulCRS = m_proj.SetProjectionSimple(false, iUTMZone, iDatum);
break;
case 1: // utm
m_proj.SetProjectionSimple(true, iUTMZone, iDatum);
break;
case 3: // Albers Conical Equal Area
{
// The Official DEM documentation says:
// "Note: All angles (latitudes, longitudes, or azimuth) are
// required in degrees, minutes, and arc seconds in the packed
// real number format +DDDOMMOSS.SSSSS."
// However, what i've actually seen is values like:
// 0.420000000000000D+06' -> 420000
// for 42 degrees, which is off by a decimal point from the DEM docs.
// So, intepret the values with factor of 10000 to convert to degrees:
// double semi_major = dProjParams[0]; // unused
// double eccentricity = dProjParams[1]; // unused
double lat_1st_std_parallel = dProjParams[2] / 10000;
double lat_2nd_std_parallel = dProjParams[3] / 10000;
double lon_central_meridian = dProjParams[4] / 10000;
double lat_origin = dProjParams[5] / 10000;
double false_easting = dProjParams[6];
double false_northing = dProjParams[7];
m_proj.SetGeogCSFromDatum(iDatum);
m_proj.SetACEA(lat_1st_std_parallel, lat_2nd_std_parallel, lat_origin,
lon_central_meridian, false_easting, false_northing);
}
break;
case 2: // State Plane (!)
case 4: // Lambert Conformal
case 5: // Mercator
case 6: // Polar Stereographic
case 7: // Polyconic
case 8: // Equidistant Conic Type A / B
case 9: // Transverse Mercator
case 10: // Stereographic
case 11: // Lambert Azimuthal Equal-Area
case 12: // Azimuthal Equidistant
case 13: // Gnomonic
case 14: // Orthographic
case 15: // General Vertical Near-Side Perspective
case 16: // Sinusoidal (Plate Caree)
case 17: // Equirectangular
case 18: // Miller Cylindrical
case 19: // Van Der Grinten I
case 20: // Oblique Mercator
VTLOG("Warning! We don't yet support DEM coordinate system %d.\n", iCoordSystem);
break;
}
// We must have a functional CRS, or it will sebsequently fail
if (!bSuccessfulCRS)
{
SetError(err, vtElevError::READ_CRS, "Couldn't determine CRS of DEM file");
return false;
}
double dElevMin, dElevMax;
DConvert(fp, 24, dElevMin, DEBUG_DEM);
DConvert(fp, 24, dElevMax, DEBUG_DEM);
fseek(fp, 852, 0);
int iRows, iProfiles;
IConvert(fp, 6, iRows); // This "Rows" value will always be 1
IConvert(fp, 6, iProfiles);
VTLOG("DEM profiles: %d\n", iProfiles);
m_iSize.x = iProfiles;
// values we'll need while scanning the elevation profiles
int iProfileRows, iProfileCols;
int iElev;
double dLocalDatumElev, dProfileMin, dProfileMax;
int ygap;
double dMinY;
DPoint2 start;
if (bGeographic)
{
// If it's in degrees, it's flush square, so we can simply
// derive the extents (m_EarthExtents) from the quad corners (m_Corners)
ComputeExtentsFromCorners();
dMinY = std::min(corners[0].y, corners[3].y);
}
else
{
VTLOG("DEM scanning to compute extents\n");
m_EarthExtents.SetInsideOut();
if (!bFixedLength)
fseek(fp, iDataStartOffset, 0);
// Need to scan over all the profiles, accumulating the TRUE
// extents of the actual data points.
int record = 0;
int data_len;
for (i = 0; i < iProfiles; i++)
{
if (progress_callback != NULL)
progress_callback(i*49/iProfiles);
if (bFixedLength)
fseek(fp, iDataStartOffset + (record * 1024), 0);
// We cannot use IConvert here, because there *might* be a spurious LF
// after the number - seen in some rare files.
if (fscanf(fp, "%d", &iRow) != 1)
{
SetError(err, vtElevError::READ_DATA, "Error reading DEM at profile %d of %d",
i, iProfiles);
return false;
}
IConvert(fp, 6, iColumn);
// assert(iColumn == i+1);
IConvert(fp, 6, iProfileRows);
IConvert(fp, 6, iProfileCols);
DConvert(fp, 24, start.x);
DConvert(fp, 24, start.y);
m_EarthExtents.GrowToContainPoint(start);
start.y += ((iProfileRows-1) * dydelta);
m_EarthExtents.GrowToContainPoint(start);
if (bFixedLength)
{
record++;
data_len = 144 + (iProfileRows * 6);
while (data_len > 1020) // max bytes in a record
{
data_len -= 1020;
record++;
}
}
else
{
DConvert(fp, 24, dLocalDatumElev);
DConvert(fp, 24, dProfileMin);
DConvert(fp, 24, dProfileMax);
for (j = 0; j < iProfileRows; j++)
{
// We cannot use IConvert here, because there *might* be a spurious LF
// after the number - seen in some rare files.
if (fscanf(fp, "%d", &iElev) != 1)
return false;
}
}
}
dMinY = m_EarthExtents.bottom;
}
VTLOG("DEM extents LRTB: %lf, %lf, %lf, %lf\n", m_EarthExtents.left,
m_EarthExtents.right, m_EarthExtents.top, m_EarthExtents.bottom);
// Compute number of rows
double fRows;
if (bGeographic)
{
// degrees
fRows = m_EarthExtents.Height() / dydelta * 3600.0f;
m_iSize.y = (int)fRows + 1; // 1 more than quad spacing
}
else
{
// some linear coordinate system
fRows = m_EarthExtents.Height() / dydelta;
m_iSize.y = (int)(fRows + 0.5) + 1; // round to the nearest integer
}
// safety check
if (m_iSize.y > 20000)
return false;
if (!AllocateGrid(err))
return false;
// jump to start of actual data
fseek(fp, iDataStartOffset, 0);
for (i = 0; i < iProfiles; i++)
{
if (progress_callback != NULL)
progress_callback(50+i*49/iProfiles);
// We cannot use IConvert here, because there *might* be a spurious LF
// after the number - seen in some rare files.
if (fscanf(fp, "%d", &iRow) != 1)
return false;
IConvert(fp, 6, iColumn);
//assert(iColumn == i+1);
IConvert(fp, 6, iProfileRows);
IConvert(fp, 6, iProfileCols);
DConvert(fp, 24, start.x);
DConvert(fp, 24, start.y);
DConvert(fp, 24, dLocalDatumElev);
DConvert(fp, 24, dProfileMin);
DConvert(fp, 24, dProfileMax);
ygap = (int)((start.y - dMinY)/dydelta);
for (j = ygap; j < (ygap + iProfileRows); j++)
{
//assert(j >=0 && j < m_iSize.y); // useful safety check
// We cannot use IConvert here, because there *might* be a spurious LF
// after the number - seen in some rare files.
if (fscanf(fp, "%d", &iElev) != 1)
return false;
if (iElev == -32767 || iElev == -32768)
SetValue(i, j, INVALID_ELEVATION);
else
{
// The DEM spec says:
// "A value in this array would be multiplied by the "z" spatial
// resolution (data element 15, record type A) and added to the
// "Elevation of local datum for the profile" (data element 4, record
// type B) to obtain the elevation for the point."
SetValue(i, j, (short) iElev + (short) dLocalDatumElev);
}
}
}
fclose(fp);
m_fVMeters = (float) (fVertUnits * dzdelta);
ComputeHeightExtents();
if (m_fMinHeight != dElevMin || m_fMaxHeight != dElevMax)
VTLOG("DEM Reader: elevation extents in .dem (%.1f, %.1f) don't match data (%.1f, %.1f).\n",
dElevMin, dElevMax, m_fMinHeight, m_fMaxHeight);
return true;
}
emDirEntry::~emDirEntry()
{
if (!--Data->RefCount) FreeData();
}
void emDirEntry::PrivLoad(const emString & path, const emString & name)
{
#if defined(_WIN32)
WIN32_FILE_ATTRIBUTE_DATA fad;
BOOL b;
if (!--Data->RefCount) FreeData();
Data=new SharedData;
Data->Path=path;
Data->Name=name;
Data->TargetPath=Data->Path;
if (em_stat(Data->Path,&Data->Stat)) {
Data->LStatErrNo=errno;
Data->StatErrNo=errno;
memset(&Data->Stat,0,sizeof(struct em_stat));
}
Data->Owner=emString::Format("%u",Data->Stat.st_uid);
Data->Group=emString::Format("%u",Data->Stat.st_gid);
b=GetFileAttributesEx(Data->Path.Get(),GetFileExInfoStandard,&fad);
Data->WndsFileAttributes = b ? fad.dwFileAttributes : 0;
Data->Hidden=(Data->WndsFileAttributes&FILE_ATTRIBUTE_HIDDEN)!=0;
#else
char tmp[1024];
#if !defined(ANDROID)
struct passwd pwbuf;
struct group grbuf;
#endif
struct passwd * pw;
struct group * gr;
int i;
if (!--Data->RefCount) FreeData();
Data=new SharedData;
Data->Path=path;
Data->Name=name;
Data->TargetPath=Data->Path;
if (em_lstat(Data->Path,&Data->Stat)) {
Data->LStatErrNo=errno;
if (em_stat(Data->Path,&Data->Stat)) {
Data->StatErrNo=errno;
memset(&Data->Stat,0,sizeof(struct em_stat));
}
else {
Data->LStat=(struct em_stat*)malloc(sizeof(struct em_stat));
memset(Data->LStat,0,sizeof(struct em_stat));
}
}
else if (S_ISLNK(Data->Stat.st_mode)) {
Data->LStat=(struct em_stat*)malloc(sizeof(struct em_stat));
memcpy(Data->LStat,&Data->Stat,sizeof(struct em_stat));
if (em_stat(Data->Path,&Data->Stat)) {
Data->StatErrNo=errno;
memset(&Data->Stat,0,sizeof(struct em_stat));
}
i=readlink(Data->Path,tmp,sizeof(tmp)-1);
if (i<0) {
Data->TargetPathErrNo=errno;
tmp[0]=0;
}
else {
tmp[i]=0;
}
Data->TargetPath=tmp;
}
#if defined(ANDROID)
pw=getpwuid(Data->Stat.st_uid);
i=0;
#else
i=getpwuid_r(Data->Stat.st_uid,&pwbuf,tmp,sizeof(tmp),&pw);
#endif
if (i==0 && pw && pw->pw_name) Data->Owner=pw->pw_name;
else Data->Owner=emString::Format("%lu",(unsigned long)Data->Stat.st_uid);
#if defined(ANDROID)
gr=getgrgid(Data->Stat.st_gid);
i=0;
#else
i=getgrgid_r(Data->Stat.st_gid,&grbuf,tmp,sizeof(tmp),&gr);
#endif
if (i==0 && gr && gr->gr_name) Data->Group=gr->gr_name;
else Data->Group=emString::Format("%lu",(unsigned long)Data->Stat.st_gid);
Data->Hidden=(Data->Name[0]=='.');
#endif
}
/*
========================
idSoundSample_XAudio2::Load
========================
*/
void idSoundSample_XAudio2::LoadResource() {
FreeData();
if ( idStr::Icmpn( GetName(), "_default", 8 ) == 0 ) {
MakeDefault();
return;
}
if ( s_noSound.GetBool() ) {
MakeDefault();
return;
}
loaded = false;
for ( int i = 0; i < 2; i++ ) {
idStrStatic< MAX_OSPATH > sampleName = GetName();
if ( ( i == 0 ) && !sampleName.Replace( "/vo/", va( "/vo/%s/", sys_lang.GetString() ) ) ) {
i++;
}
idStrStatic< MAX_OSPATH > generatedName = "generated/";
generatedName.Append( sampleName );
{
if ( s_useCompression.GetBool() ) {
sampleName.Append( ".msadpcm" );
} else {
sampleName.Append( ".wav" );
}
generatedName.Append( ".idwav" );
}
loaded = LoadGeneratedSample( generatedName ) || LoadWav( sampleName );
if ( !loaded && s_useCompression.GetBool() ) {
sampleName.SetFileExtension( "wav" );
loaded = LoadWav( sampleName );
}
if ( loaded ) {
if ( cvarSystem->GetCVarBool( "fs_buildresources" ) ) {
fileSystem->AddSamplePreload( GetName() );
WriteAllSamples( GetName() );
if ( sampleName.Find( "/vo/" ) >= 0 ) {
for ( int i = 0; i < Sys_NumLangs(); i++ ) {
const char * lang = Sys_Lang( i );
if ( idStr::Icmp( lang, ID_LANG_ENGLISH ) == 0 ) {
continue;
}
idStrStatic< MAX_OSPATH > locName = GetName();
locName.Replace( "/vo/", va( "/vo/%s/", Sys_Lang( i ) ) );
WriteAllSamples( locName );
}
}
}
return;
}
}
if ( !loaded ) {
// make it default if everything else fails
MakeDefault();
}
return;
}
/*
========================
idSoundSample_XAudio2::~idSoundSample_XAudio2
========================
*/
idSoundSample_XAudio2::~idSoundSample_XAudio2() {
FreeData();
}
CTextureString::~CTextureString()
{
FreeData();
}
~CGamestatsData()
{
FreeData();
}
// Discards temporary data.
void Perspective::ReleaseIntermediate()
{
FreeData();
}
CTextureStringImage::~CTextureStringImage()
{
FreeData();
}
PokerData::~PokerData(){
FreeData(true); // Free data close database.
}
/*
================
sdDeclDamage::~sdDeclDamage
================
*/
sdDeclDamage::~sdDeclDamage( void ) {
FreeData();
}
bool
PokerData::LoadData(){
FreeData(true);
m_pDataMan = new DataManager(m_sConnString);
if( !m_pDataMan->Open() ){
delete m_pDataMan;
m_pDataMan = NULL;
return false;
}
/*
PokerAvatar avatar;
avatar.m_nId = 2;
avatar.m_recStatus = 0;
Serializable::LoadImageData(_T("d:\\avatar_1.png"), avatar.m_binData);
m_pDataMan->SaveRecord(&avatar);*/
/*
PokerAvatar avatar;
avatar.m_nId = 0;
avatar.m_recStatus = 0;
Serializable::LoadImageData(_T("d:\\avatar1.png"), avatar.m_binData);
m_pDataMan->SaveRecord(&avatar);
*/
/*
CreateUserProc* pCreateUser = new CreateUserProc();
pCreateUser->m_sUserName = _T("zack");
pCreateUser->m_sPassword = _T("zack");
m_pDataMan->ExecuteProc(pCreateUser);
delete pCreateUser;
*/
/*
TestTableProc* pTestProc = new TestTableProc();
pTestProc->m_str = "test";
pTestProc->m_date = COleDateTime::GetCurrentTime();
pTestProc->m_datetime = COleDateTime::GetCurrentTime();
pTestProc->m_big = 5555555555555;
pTestProc->m_float = 123.89f;
pTestProc->m_real = 1234444.89;
pTestProc->m_dec = 1234441.89;
pTestProc->m_num = 1234440.89;
pTestProc->m_money = 123.89988;
Serializable::GlobalReAlloc(&pTestProc->m_binary, 20);
BYTE* lp = (BYTE*)GlobalLock(pTestProc->m_binary.m_hData);
lp[0] = 'z';
lp[1] = 'a';
lp[2] = 'q';
lp[3] = 'q';
lp[4] = 'q';
lp[5] = 'q';
lp[6] = 'q';
lp[7] = 'z';
GlobalUnlock(pTestProc->m_binary.m_hData);
m_pDataMan->ExecuteProc(pTestProc);
delete pTestProc;
*/
/*
EnumerableObject<TestTable>* pTest = new EnumerableObject<TestTable>();
m_pDataMan->LoadTable((EnumerableObject<Serializable>*)pTest);
if( pTest->GetCount() > 0 ){
TestTable* pRec = pTest->GetAt(0);
// pRec->m_nId = 0;
pRec->m_str = "zaqro [changed]";
//Serializable::FreeBinary(&pRec->m_binary);
//m_pDataMan->DeleteRecord(pRec);
//m_pDataMan->SaveRecord(pRec);
}
delete pTest;
*/
m_lockAttributeTables.Lock(); // Lock
m_pDataMan->LoadTable((EnumerableObject<Serializable>*)&m_listGameType, _T(""), _T("")); // Game type
m_pDataMan->LoadTable((EnumerableObject<Serializable>*)&m_listGameSubType, _T(""), _T("")); // Game sub type
m_pDataMan->LoadTable((EnumerableObject<Serializable>*)&m_listMoneyType, _T(""), _T("")); // Money type
m_pDataMan->LoadTable((EnumerableObject<Serializable>*)&m_listGameSpeed, _T(""), _T("")); // Game speed
m_lockAttributeTables.Unlock(); // Unlock
return true;
}
/*
================
idDeclAF::idDeclAF
================
*/
idDeclAF::idDeclAF( void ) {
FreeData();
}
CIrssMessage::~CIrssMessage()
{
FreeData();
}
MJsonValue::~MJsonValue()
{
FreeData();
}
FStringTable::~FStringTable ()
{
FreeData ();
}
~ProfileNodeInfo()
{
FreeData();
}
otSpeexDecoder::~otSpeexDecoder()
{
FreeData();
}
