本文整理汇总了C++中Open函数的典型用法代码示例。如果您正苦于以下问题：C++ Open函数的具体用法？C++ Open怎么用？C++ Open使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Open函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: m_File
cFile::cFile(const AString & iFileName, eMode iMode) :
m_File(nullptr)
{
Open(iFileName, iMode);
}示例2: RecSlaveEntry
void RecSlaveEntry(void)
{
struct AHIAudioCtrlDrv* AudioCtrl;
struct DriverBase* AHIsubBase;
struct FilesaveBase* FilesaveBase;
ULONG signals;
BPTR lock = NULL,cd=0,file = NULL;
Object *o = NULL;
BYTE *samples = NULL;
ULONG length = NULL;
ULONG count = 0,offs = 0,i;
struct AHIRecordMessage RecordMessage =
{
AHIST_S16S,
NULL,
RECBUFFERSIZE
};
AudioCtrl = (struct AHIAudioCtrlDrv*) FindTask( NULL )->tc_UserData;
AHIsubBase = (struct DriverBase*) dd->fs_AHIsubBase;
FilesaveBase = (struct FilesaveBase*) AHIsubBase;
RecordMessage.ahirm_Buffer = dd->fs_RecBuffer;
if(!(lock = Lock(dd->fs_RecFileReq->fr_Drawer,ACCESS_READ)))
goto quit;
cd = CurrentDir(lock);
if(DataTypesBase)
{
struct TagItem newtags[] =
{
{ DTA_GroupID, GID_SOUND },
{ TAG_DONE, 0 }
};
struct TagItem attrtags[] =
{
{ SDTA_Sample, (ULONG) &samples },
{ SDTA_SampleLength, (ULONG) &length },
{ TAG_DONE, 0 }
};
if (!(o = NewDTObjectA (dd->fs_RecFileReq->fr_File, newtags)))
goto quit;
GetDTAttrsA(o, attrtags );
}
else // datatypes.library not open. Open the selected file as raw 8 bit signed instead.
{
if(!(file = Open(dd->fs_RecFileReq->fr_File,MODE_OLDFILE)))
goto quit;
Seek(file,0,OFFSET_END);
length = Seek(file,0,OFFSET_BEGINNING);
if(!(samples = AllocVec(length,MEMF_ANY)))
goto quit;
if(length != (ULONG) Read(file,samples,length))
goto quit;
}
if(!samples || !length )
goto quit;
if((dd->fs_RecSlaveSignal = AllocSignal(-1)) == -1)
goto quit;
// Everything set up. Tell Master we're alive and healthy.
Signal((struct Task *)dd->fs_MasterTask,1L<<dd->fs_RecMasterSignal);
for(;;)
{
signals = SetSignal(0L,0L);
if(signals & (SIGBREAKF_CTRL_C | 1L<<dd->fs_RecSlaveSignal))
break;
for(;;)
{
if(count+RECBUFFERSIZE-offs < length)
{
// End of sample will not be reached; just fill to the end of dd->fs_RecBuffer.
for(i = RECBUFFERSIZE-offs;i>0;i--)
{
dd->fs_RecBuffer[(offs)<<1] =
dd->fs_RecBuffer[((offs++)<<1)+1] =
samples[count++]<<8;
}
offs = 0;
break;
}
else
{
// End of sample will be reached. Fill part of buffer, and iterate (== don't break).
for(i = length-count;i>0;i--)
{
dd->fs_RecBuffer[(offs)<<1] =
dd->fs_RecBuffer[((offs++)<<1)+1] =
samples[count++]<<8;
}
//.........这里部分代码省略.........
示例3: Visible
void DtPrinterIcon::NotifyVisiblity(BaseUI *obj)
{
if (app_mode == CONFIG_PRINTERS)
return;
if (obj == flag)
{
boolean show_it = Visible();
if (show_it)
{
if (mainw->setPrefD->ShowStatusFlags() == false)
show_it = false;
else
{
#ifdef aix
if (_print_queue_up)
{
show_it = false;
int i;
for (i = 0; i < n_devices; i++)
if (_print_device_up[i] == false)
{
show_it = true;
break;
}
}
else
show_it = true;
#else
if (_print_queue_up && _print_device_up)
show_it = false;
else
show_it = true;
#endif
}
}
if (flag->Visible() != show_it)
flag->Visible(show_it);
}
else if (obj == details_label)
{
boolean show_it = Visible();
if (show_it)
{
if (container && IconView() == DETAILS && Open())
{
if (container->NumChildren() == 0 ||
(container->Children()[0])->UIClass() == LABEL)
show_it = false;
else if (mainw->setPrefD->ShowDetailsLabel())
{
show_it = false;
int i;
BaseUI **children = container->Children();
for (i = 0; i < container->NumChildren(); i++)
if (children[i]->Visible())
{
show_it = true;
break;
}
}
else
show_it = mainw->setPrefD->ShowDetailsLabel();
}
else
show_it = false;
}
if (details_label->Visible() != show_it)
details_label->Visible(show_it);
}
}示例4: ReadConfig
BOOL
ReadConfig ( struct AHIDevUnit *iounit,
struct AHIBase *AHIBase )
{
struct IFFHandle *iff;
struct StoredProperty *prhd,*ahig;
struct CollectionItem *ci;
if(iounit)
{
/* Internal defaults for device unit */
iounit->AudioMode = AHI_INVALID_ID; // See at the end of the function!
iounit->Frequency = 10000;
iounit->Channels = 4;
iounit->MonitorVolume = ~0;
iounit->InputGain = ~0;
iounit->OutputVolume = ~0;
iounit->Input = ~0;
iounit->Output = ~0;
}
else
{
/* Internal defaults for low-level mode */
AHIBase->ahib_AudioMode = AHI_INVALID_ID;
AHIBase->ahib_Frequency = 10000;
AHIBase->ahib_MonitorVolume = 0x00000;
AHIBase->ahib_InputGain = 0x10000;
AHIBase->ahib_OutputVolume = 0x10000;
AHIBase->ahib_Input = 0;
AHIBase->ahib_Output = 0;
}
if((iff=AllocIFF()))
{
iff->iff_Stream=Open("ENV:Sys/ahi.prefs", MODE_OLDFILE);
if(iff->iff_Stream)
{
InitIFFasDOS(iff);
if(!OpenIFF(iff,IFFF_READ))
{
if(!(PropChunk(iff,ID_PREF,ID_PRHD)
|| PropChunk(iff,ID_PREF,ID_AHIG)
|| CollectionChunk(iff,ID_PREF,ID_AHIU)
|| StopOnExit(iff,ID_PREF,ID_FORM)))
{
if(ParseIFF(iff,IFFPARSE_SCAN) == IFFERR_EOC)
{
prhd=FindProp(iff,ID_PREF,ID_PRHD);
ahig=FindProp(iff,ID_PREF,ID_AHIG);
if(ahig)
{
struct AHIGlobalPrefs *globalprefs;
globalprefs = (struct AHIGlobalPrefs *)ahig->sp_Data;
AHIBase->ahib_DebugLevel = globalprefs->ahigp_DebugLevel;
AHIBase->ahib_Flags = 0;
if(globalprefs->ahigp_DisableSurround)
AHIBase->ahib_Flags |= AHIBF_NOSURROUND;
if(globalprefs->ahigp_DisableEcho)
AHIBase->ahib_Flags |= AHIBF_NOECHO;
if(globalprefs->ahigp_FastEcho)
AHIBase->ahib_Flags |= AHIBF_FASTECHO;
if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs,
ahigp_MaxCPU) )
{
AHIBase->ahib_MaxCPU = globalprefs->ahigp_MaxCPU;
}
else
{
AHIBase->ahib_MaxCPU = 0x10000 * 90 / 100;
}
if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs,
ahigp_ClipMasterVolume) )
{
if(globalprefs->ahigp_ClipMasterVolume)
AHIBase->ahib_Flags |= AHIBF_CLIPPING;
}
if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs,
ahigp_AntiClickTime ) )
{
AHIBase->ahib_AntiClickTime = globalprefs->ahigp_AntiClickTime;
}
else
{
AHIBase->ahib_AntiClickTime = 0;
}
}
ci=FindCollection(iff,ID_PREF,ID_AHIU);
while(ci)
{
//.........这里部分代码省略.........
示例5: infile
void DataStore::ImportDataFromFile(std::string const &file)
{
std::ifstream infile(file);
std::string line;
std::getline(infile, line); //skip first line (assume it's always a header)
std::vector<std::pair<Record, bool>> vRecordsToAdd; //boolean keeps track if Record already exists in datastore
//Add all Records from input file to temporary storage
while (std::getline(infile, line)) {
std::vector<std::string> const tokens(Utility::Tokenize(line, "|"));
if (tokens.size() != 6)
throw std::runtime_error("Bad record in file (found " + std::to_string(tokens.size()) + " fields, expected 6)");
Record const rec(tokens);
vRecordsToAdd.emplace_back(std::make_pair(rec, false));
}
std::cout << vRecordsToAdd.size() << " record(s) read from file" << std::endl;
//Read data store (from file) and update existing records
size_t numUpdated(0);
Open();
size_t const size(GetNumRecords());
for (size_t ii = 0; ii < size; ++ii) {
Record const oldRec(FetchRecord(ii));
for (auto &pp : vRecordsToAdd) {
Record const &rec (pp.first);
bool &added(pp.second);
if (added)
continue;
if (rec == oldRec) {
UpdateRecord(rec, ii);
added = true;
++numUpdated;
}
}
}
if (numUpdated > 0)
std::cout << numUpdated << " record(s) updated in datastore" << std::endl;
//Finally, add brand new records to datastore
size_t numAdded(0);
for (auto const &pp : vRecordsToAdd) {
Record const &rec(pp.first);
bool const &added(pp.second);
if (!added) {
AddRecord(rec);
++numAdded;
}
}
if (numAdded > 0)
std::cout << numAdded << " record(s) added to datastore" << std::endl;
Close();
}示例6: Open
bool COutFile::Open(LPCWSTR fileName, DWORD creationDisposition)
{
return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL);
}示例7: af_GetFullPath
bool AFileUnicode::Open(const char* szFolderName, const char * szFileName, ADWORD dwFlags)
{
char szFullPath[AMAX_PATH];
af_GetFullPath(szFullPath, szFolderName, szFileName);
return Open(szFullPath, dwFlags);
}示例8: ReadRasterColumn
CPLErr NTFFileReader::ReadRasterColumn( int iColumn, float *pafElev )
{
/* -------------------------------------------------------------------- */
/* If we don't already have the scanline offset of the previous */
/* line, force reading of previous records to establish it. */
/* -------------------------------------------------------------------- */
if( panColumnOffset[iColumn] == 0 )
{
int iPrev;
for( iPrev = 0; iPrev < iColumn-1; iPrev++ )
{
if( panColumnOffset[iPrev+1] == 0 )
{
CPLErr eErr;
eErr = ReadRasterColumn( iPrev, NULL );
if( eErr != CE_None )
return eErr;
}
}
}
/* -------------------------------------------------------------------- */
/* If the dataset isn't open, open it now. */
/* -------------------------------------------------------------------- */
if( GetFP() == NULL )
Open();
/* -------------------------------------------------------------------- */
/* Read requested record. */
/* -------------------------------------------------------------------- */
NTFRecord *poRecord;
SetFPPos( panColumnOffset[iColumn], iColumn );
poRecord = ReadRecord();
if( iColumn < nRasterXSize-1 )
{
GetFPPos( panColumnOffset+iColumn+1, NULL );
}
/* -------------------------------------------------------------------- */
/* Handle LANDRANGER DTM columns. */
/* -------------------------------------------------------------------- */
if( pafElev != NULL && GetProductId() == NPC_LANDRANGER_DTM )
{
double dfVScale, dfVOffset;
dfVOffset = atoi(poRecord->GetField(56,65));
dfVScale = atoi(poRecord->GetField(66,75)) * 0.001;
for( int iPixel = 0; iPixel < nRasterXSize; iPixel++ )
{
pafElev[iPixel] = (float) (dfVOffset + dfVScale *
atoi(poRecord->GetField(84+iPixel*4,87+iPixel*4)));
}
}
/* -------------------------------------------------------------------- */
/* Handle PROFILE */
/* -------------------------------------------------------------------- */
else if( pafElev != NULL && GetProductId() == NPC_LANDFORM_PROFILE_DTM )
{
for( int iPixel = 0; iPixel < nRasterXSize; iPixel++ )
{
pafElev[iPixel] = (float)
(atoi(poRecord->GetField(19+iPixel*5,23+iPixel*5)) * GetZMult());
}
}
delete poRecord;
return CE_None;
}示例9: procan
int procan(FILE *outfile) {
/*filan(0, outfile);*/
/* controlling terminal */
fprintf(outfile, "process id = "F_pid"\n", Getpid());
fprintf(outfile, "process parent id = "F_pid"\n", Getppid());
{
int fd;
if ((fd = Open("/dev/tty", O_NOCTTY, 0)) < 0) {
fprintf(outfile, "controlling terminal: -\n");
} else {
#if 1
fprintf(outfile, "controlling terminal: \"%s\"\n", Ttyname(fd));
#else
char procpath[PATH_MAX], devpath[PATH_MAX+1];
int devlen;
sprintf(procpath, "/proc/"F_pid"/fd/%d", Getpid(), 0 /*! fd*/);
if ((devlen = Readlink(procpath, devpath, sizeof(devpath))) < 0) {
;
} else {
devpath[devlen] = '\0';
fprintf(outfile, "controlling terminal: \"%s\"\n", devpath);
}
#endif
}
}
fprintf(outfile, "process group id = "F_pid"\n", Getpgrp());
#if HAVE_GETSID
fprintf(outfile, "process session id = "F_pid"\n", Getsid(0));
#endif
fprintf(outfile, "process group id if fg process / stdin = "F_pid"\n", Tcgetpgrp(0));
fprintf(outfile, "process group id if fg process / stdout = "F_pid"\n", Tcgetpgrp(1));
fprintf(outfile, "process group id if fg process / stderr = "F_pid"\n", Tcgetpgrp(2));
{
int fd;
if ((fd = Open("/dev/tty", O_RDWR, 0600)) >= 0) {
fprintf(outfile, "process has a controlling terminal\n");
Close(fd);
} else {
fprintf(outfile, "process does not have a controlling terminal\n");
}
}
/* process owner, groups */
fprintf(outfile, "user id = "F_uid"\n", Getuid());
fprintf(outfile, "effective user id = "F_uid"\n", Geteuid());
fprintf(outfile, "group id = "F_gid"\n", Getgid());
fprintf(outfile, "effective group id = "F_gid"\n", Getegid());
{
struct rlimit rlim;
fprintf(outfile, "\nRESOURCE LIMITS\n");
fprintf(outfile, "resource current maximum\n");
if (getrlimit(RLIMIT_CPU, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_CPU, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"cpu time (seconds) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_FSIZE, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_FSIZE, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"file size (blocks) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_DATA, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_DATA, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"data seg size (kbytes) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_STACK, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_STACK, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"stack size (blocks) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_CORE, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_CORE, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"core file size (blocks) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#ifdef RLIMIT_RSS /* Linux, AIX; not Cygwin */
if (getrlimit(RLIMIT_RSS, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_RSS, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"max resident set size %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#endif
#ifdef RLIMIT_NPROC /* Linux, not AIX, Cygwin */
//.........这里部分代码省略.........
示例10: m_file
IOFile::IOFile(const std::string& filename, const char openmode[])
: m_file(NULL), m_good(true)
{
Open(filename, openmode);
}示例11: vfsStream
vfsStreamMemory::vfsStreamMemory(u64 addr) : vfsStream()
{
Open(addr);
}示例12: Open
/*
--------------------------------------------------------------------------------
open ...
(Standard instances management. Driver specific implementations should be put in Open() function.)
--------------------------------------------------------------------------------
*/
ST_ErrorCode_t STEXTVIN_Open(const ST_DeviceName_t DeviceName, const STEXTVIN_OpenParams_t * const OpenParams_p, STEXTVIN_Handle_t *Handle_p)
{
S32 DeviceIndex = INVALID_DEVICE_INDEX, UnitIndex, Index;
U32 OpenedUnitForThisInit;
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
/* Exit now if parameters are bad */
if ((OpenParams_p == NULL) || /* There must be parameters ! */
(Handle_p == NULL) || /* Pointer to handle should be valid ! */
(strlen(DeviceName) > (ST_MAX_DEVICE_NAME - 1)) || /* Device name length should be respected */
((((const char *) DeviceName)[0]) == '\0')
)
{
return(ST_ERROR_BAD_PARAMETER);
}
EnterCriticalSection();
if (!FirstInitDone)
{
ErrorCode = ST_ERROR_UNKNOWN_DEVICE;
}
else
{
/* Check if device already initialised and return error if not so */
DeviceIndex = GetIndexOfDeviceNamed(DeviceName);
if (DeviceIndex == INVALID_DEVICE_INDEX)
{
/* Device name not found */
ErrorCode = ST_ERROR_UNKNOWN_DEVICE;
}
else
{
/* Look for a free unit and check all opened units to check if MaxOpen is not reached */
UnitIndex = STEXTVIN_MAX_UNIT;
OpenedUnitForThisInit = 0;
for (Index = 0; Index < STEXTVIN_MAX_UNIT; Index++)
{
if ((STEXTVIN_UnitArray[Index].UnitValidity == STEXTVIN_VALID_UNIT) && (STEXTVIN_UnitArray[Index].Device_p == &DeviceArray[DeviceIndex]))
{
OpenedUnitForThisInit ++;
}
if (STEXTVIN_UnitArray[Index].UnitValidity != STEXTVIN_VALID_UNIT)
{
/* Found a free handle structure */
UnitIndex = Index;
}
}
if ((OpenedUnitForThisInit >= DeviceArray[DeviceIndex].MaxOpen) || (UnitIndex >= STEXTVIN_MAX_UNIT))
{
/* None of the units is free or MaxOpen reached */
ErrorCode = ST_ERROR_NO_FREE_HANDLES;
}
else
{
*Handle_p = (STEXTVIN_Handle_t) &STEXTVIN_UnitArray[UnitIndex];
STEXTVIN_UnitArray[UnitIndex].Device_p = &DeviceArray[DeviceIndex];
/* API specific actions after opening */
ErrorCode = Open(&STEXTVIN_UnitArray[UnitIndex], OpenParams_p);
if (ErrorCode == ST_NO_ERROR)
{
/* Register opened handle */
STEXTVIN_UnitArray[UnitIndex].UnitValidity = STEXTVIN_VALID_UNIT;
STTBX_Report((STTBX_REPORT_LEVEL_INFO, "Handle opened on device '%s'", DeviceName));
}
} /* End found unit unused */
} /* End device valid */
} /* End FirstInitDone */
LeaveCriticalSection();
return(ErrorCode);
} /* End fo STEXTVIN_Open() function */示例13: AppendFeature
long SmtAnnoFclsAdoLayer::AppendFeature(const SmtFeature *pSmtFeature,bool bclone)
{
long lRet = SMT_ERR_NONE;
//////////////////////////////////////////////////////////////////////////
//db
if (!IsOpen())
if (!Open(m_szLayerTableName))
return SMT_ERR_DB_OPER;
int nGridID = 0;
char szAnnoBuf[TEMP_BUFFER_SIZE];
int nClr = 0;
double fAngle = 0.;
Envelope env;
const SmtGeometry *pGeom = pSmtFeature->GetGeometryRef();
const SmtAttribute *pAtt = pSmtFeature->GetAttributeRef();
const SmtStyle *pStyle = pSmtFeature->GetStyle();
pGeom->GetEnvelope(&env);
m_SmtRecordset.AddNew();
m_SmtRecordset.PutCollect("ID",_variant_t(pSmtFeature->GetID()));
m_SmtRecordset.PutCollect("mbr_xmin",_variant_t(env.MinX));
m_SmtRecordset.PutCollect("mbr_ymin",_variant_t(env.MinY));
m_SmtRecordset.PutCollect("mbr_xmax",_variant_t(env.MaxX));
m_SmtRecordset.PutCollect("mbr_ymax",_variant_t(env.MaxY));
m_SmtRecordset.PutCollect("grid_id",_variant_t(nGridID));
//////////////////////////////////////////////////////////////////////////
lRet = AppendStyle(pStyle);
//////////////////////////////////////////////////////////////////////////
lRet = AppendGeom(pGeom);
//////////////////////////////////////////////////////////////////////////
const SmtField *pFld = NULL;
pFld = pAtt->GetFieldPtr(pAtt->GetFieldIndex("anno"));
sprintf(szAnnoBuf,pFld->GetValueAsString());
m_SmtRecordset.PutCollect("anno",_variant_t(szAnnoBuf));
pFld = pAtt->GetFieldPtr(pAtt->GetFieldIndex("color"));
nClr = pFld->GetValueAsInteger();
m_SmtRecordset.PutCollect("color",_variant_t(nClr));
pFld = pAtt->GetFieldPtr(pAtt->GetFieldIndex("angle"));
fAngle = pFld->GetValueAsDouble();
m_SmtRecordset.PutCollect("angle",_variant_t(fAngle));
if (!m_SmtRecordset.Update())
{
SMT_SAFE_DELETE(pSmtFeature);
return SMT_ERR_DB_OPER;
}
//mem
m_pMemLayer->AppendFeature(pSmtFeature,bclone);
CalEnvelope();
return lRet;
}示例14: Open
bool File::OpenTemporaryFile(const std::wstring &dir)
{
return Open(tmpnam(NULL), MODE_TEMP);
} 示例15: cJoystick
cJoystickSDL::cJoystickSDL( const Uint32& index ) :
cJoystick( index ),
mJoystick( NULL )
{
Open();
}