const char* CInvalidChoiceSelection::GetErrCodeString(void) const
{
switch ( GetErrCode() ) {
case eFail: return "eFail";
default: return CException::GetErrCodeString();
}
}
/// Translate from the error code value to its string representation
virtual const char* GetErrCodeString(void) const {
switch ( GetErrCode() ) {
case eIndexInitError: return "eIndexInitError";
case eDBMismatch: return "inconsistent database";
default: return CException::GetErrCodeString();
}
}
const char* CVariantException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eVariant: return "eVariant";
default: return CException::GetErrCodeString();
}
}
//----------------------------------------------------------------------------
const char * CSeqMasker::CSeqMaskerException::GetErrCodeString() const
{
switch( GetErrCode() )
{
case eLstatStreamIpenFail:
return "can not open input stream";
case eLstatSyntax:
return "syntax error";
case eLstatParam:
return "the following parameters could not be determined"
" from the unit frequency database or command line: ";
case eScoreAllocFail:
return "score function object allocation failed";
case eScoreP3AllocFail:
return "merge pass score function object allocation failed";
default:
return CException::GetErrCodeString();
}
}
virtual std::string GetErrCodeString() const
{
switch (GetErrCode()) {
case eKeyNotFound: return "The key was not found in any handler: " + m_extraInfo;
default: return CAnyPropertyException::GetErrCodeString();
}
}
const char* CException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eUnknown: return "eUnknown";
default: return "eInvalid";
}
}
virtual const char* GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eBadResidues: return "eBadResidues";
default: return CException::GetErrCodeString();
}
}
virtual const char* GetErrCodeString() const
{
switch (GetErrCode()) {
case eBlobTooOld: return "eBlobTooOld";
default: return CException::GetErrCodeString();
}
}
//------------------------------------------------------------------------------
const char * CSeqMaskerOstatOpt::Exception::GetErrCodeString() const
{
switch( GetErrCode() )
{
case eMemory: return "insufficient memory";
default: return CException::GetErrCodeString();
}
}
const char* CBDB_ErrnoException::GetErrCodeString(void) const
{
switch ( GetErrCode() ) {
case eSystem: return "eSystem";
case eBerkeleyDB: return "eBerkeleyDB";
default: return CException::GetErrCodeString();
}
}
virtual const char* GetErrCodeString(void) const
{
switch(GetErrCode()) {
case eInvalidSeqAnnot: return "eInvalidSeqAnnot";
case eImageRenderError: return "eImageRenderError";
default: return CException::GetErrCodeString();
};
}
const char* CConnException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eConn: return "eConn";
default: break;
}
return CException::GetErrCodeString();
}
STDMETHODIMP CComBus::Start(void)
{
// TODO: Add your implementation code here
m_ErrCode = 0;
if( !OpenPort( (LPTSTR)(m_port->m_str), m_baudrate ) )
{
m_ErrCode = GetErrCode();
return E_FAIL;
}
if( !CreateThread() )
{
m_ErrCode = GetErrCode();
return E_FAIL;
}
::Sleep(1000);
return S_OK;
}
const char* CRequestContextException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eBadSession: return "eBadSession";
case eBadHit: return "eBadHit";
default: return CException::GetErrCodeString();
}
}
//------------------------------------------------------------------------------
const char *
CWinMaskCountsConverter::Exception::GetErrCodeString() const
{
switch( GetErrCode() ) {
case eBadOption: return "argument error";
default: return CException::GetErrCodeString();
}
}
const char* CCompoundIDException::GetErrCodeString() const
{
switch (GetErrCode()) {
case eInvalidType:
return "eInvalidType";
default:
return CException::GetErrCodeString();
}
}
virtual const char* GetErrCodeString(void) const {
switch (GetErrCode()) {
case eInvalid : return "eInvalid";
case eIndexOutOfBounds : return "eIndexOutOfBounds";
case eInvalidResidue : return "eInvalidResidue";
case eNoResidueInfo : return "eNoResidueInfo";
}
return "UnknownError";
}
virtual const char * GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eNumberOfFieldsMismatch:
return "eNumberOfFieldsMismatch";
default:
return CException::GetErrCodeString();
}
}
/// Get a message describing the situation leading to the throw.
virtual const char* GetErrCodeString() const
{
switch ( GetErrCode() ) {
case eConfigErr: return "eConfigErr";
case eMemErr: return "eMemErr";
case eInternal: return "eInternal";
default: return CException::GetErrCodeString();
}
}
virtual std::string GetErrCodeString() const
{
std::string errorString;
switch (GetErrCode()) {
case eEmptyKey: errorString = "The key provided was empty";
case eNoReadHandler: errorString = "No handler was installed to read this type";
case eNoWriteHandler: errorString = "No handler was installed to write this type";
case eBadReadType: errorString = "A handler found a type it couldn't write";
case eBadWriteType: errorString = "A handler found a type it couldn't write";
case eFileOpenFailed: errorString = "A file could not be opened";
case eNoGet: errorString = "This handler does not implement Get";
case eNoSet: errorString = "This handler does not implement Set";
case ePutenvFailed: errorString = "Putenv failed.";
default: errorString = "Unknown property exception with error code "
+ std::to_string(GetErrCode());
return errorString + ": " + m_extraInfo;
}
}
virtual const char* GetErrCodeString(void) const {
switch ( GetErrCode() ) {
case eInternal:
return "eInternal";
case eGeneral:
return "eGeneral";
default:
return CException::GetErrCodeString();
}
}
const char* CParamException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eParserError: return "eParserError";
case eBadValue: return "eBadValue";
case eNoThreadValue: return "eNoThreadValue";
case eRecursion: return "eRecursion";
default: return CException::GetErrCodeString();
}
}
virtual const char* GetErrCodeString() const
{
switch (GetErrCode()) {
case eInvalidKey: return "eInvalidKey";
case eAsnObjectNotMatch: return "eAsnObjectNotMatch";
case eUnsupportedSerialFmt: return "eUnsupportedSerialFmt";
case eUnsupportedCompression: return "eUnsupportedCompression";
default: return CException::GetErrCodeString();
}
}
BEGIN_NCBI_SCOPE
//------------------------------------------------------------------------------
const char * CSeqMaskerOstat::CSeqMaskerOstatException::GetErrCodeString() const
{
switch( GetErrCode() )
{
case eBadState: return "bad state";
default: return CException::GetErrCodeString();
}
}
const char* CUnassignedMember::GetErrCodeString(void) const
{
#if 0
switch ( GetErrCode() ) {
case eGet: return "eGet";
case eWrite: return "eWrite";
case eUnknownMember: return "eUnknownMember";
default: return CException::GetErrCodeString();
}
#else
// At least with ICC 9.0 on 64-bit Linux in Debug and MT mode
// there is an apparent bug that causes the above "switch" based
// variant of this function to misbehave and crash with SEGV...
TErrCode e = GetErrCode();
if (e == eGet) {return "eGet";}
if (e == eWrite) {return "eWrite";}
if (e == eUnknownMember) {return "eUnknownMember";}
return CException::GetErrCodeString();
#endif
}
const char* CCoreException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eCore: return "eCore";
case eNullPtr: return "eNullPtr";
case eDll: return "eDll";
case eDiagFilter: return "eDiagFilter";
case eInvalidArg: return "eInvalidArg";
default: return CException::GetErrCodeString();
}
}
BEGIN_NCBI_SCOPE
const char* CGetPasswordFromConsoleException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eGetPassError: return "eGetPassError";
case eKeyboardInterrupt: return "eKeyboardInterrupt";
default: return CException::GetErrCodeString();
}
}
inline
const char* CEditException::GetErrCodeString(void) const
{
switch ( GetErrCode() ) {
case eNotImplemented:
return "eNotImplemented";
case eInvalid:
return "eInvalid";
default:
return CException::GetErrCodeString();
}
}
const char* CInterProcessLockException::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eLockTimeout: return "eLockTimeout";
case eCreateError: return "eCreateError";
case eLockError: return "eLockError";
case eUnlockError: return "eUnlockError";
case eMultipleLocks: return "eMultipleLocks";
case eNotLocked: return "eNotLocked";
default: return CException::GetErrCodeString();
}
}
const char* CIO_Exception::GetErrCodeString(void) const
{
switch (GetErrCode()) {
case eTimeout: return "eIO_Timeout";
case eClosed: return "eIO_Closed";
case eInterrupt: return "eIO_Interrupt";
case eInvalidArg: return "eIO_InvalidArg";
case eNotSupported: return "eIO_NotSupported";
case eUnknown: return "eIO_Unknown";
default: break;
}
return CException::GetErrCodeString();
}