ACS_Base* ACS_Idle::NextState(AppLayerChannel* c, FunctionCodes aFunc, bool aConfirm) { switch(aFunc) { case(FC_CONFIRM): MACRO_THROW_EXCEPTION(ArgumentException, "Confirms are automatic only"); case(FC_RESPONSE): if(c->Sequence() < 0) { MACRO_THROW_EXCEPTION(InvalidStateException, "Can't respond until we've received a request"); } case(FC_UNSOLICITED_RESPONSE): if(aConfirm) return ACS_SendConfirmed::Inst(); else return ACS_Send::Inst(); case(FC_DIRECT_OPERATE_NO_ACK): if(aConfirm) { MACRO_THROW_EXCEPTION(ArgumentException, "DO no ACK can't be confirmed"); } return ACS_Send::Inst(); default: // it's a request with an expected response if(aConfirm) { MACRO_THROW_EXCEPTION(ArgumentException, "Confirmation not allowed for requests"); } return ACS_SendExpectResponse::Inst(); } }
void AsyncTaskBase::Dispatch() { if(mIsRunning) MACRO_THROW_EXCEPTION(InvalidStateException, "Running"); if(!mIsEnabled) MACRO_THROW_EXCEPTION(InvalidStateException, "Disabled"); mIsRunning = true; mIsComplete = false; mIsExpired = false; mHandler(this); }
void AsyncTaskBase::AddDependency(const AsyncTaskBase* apTask) { if(apTask == this) MACRO_THROW_EXCEPTION(ArgumentException, "Self-dependency not allowed"); if(apTask->IsDependency(this)) MACRO_THROW_EXCEPTION(ArgumentException, "Circular dependencies not allowed"); mDependencies.push_back(apTask); }
void Database::SetClass(DataTypes aType, size_t aIndex, PointClass aClass) { switch(aType) { case(DT_BINARY): if(aIndex >= mBinaryVec.size()) MACRO_THROW_EXCEPTION_WITH_CODE(Exception, "", ERR_INDEX_OUT_OF_BOUNDS); mBinaryVec[aIndex].mClass = aClass; break; case(DT_ANALOG): if(aIndex >= mAnalogVec.size()) MACRO_THROW_EXCEPTION_WITH_CODE(Exception, "", ERR_INDEX_OUT_OF_BOUNDS); mAnalogVec[aIndex].mClass = aClass; break; case(DT_COUNTER): if(aIndex >= mCounterVec.size()) MACRO_THROW_EXCEPTION_WITH_CODE(Exception, "", ERR_INDEX_OUT_OF_BOUNDS); mCounterVec[aIndex].mClass = aClass; break; case(DT_CONTROL_STATUS): if(aIndex >= mControlStatusVec.size()) MACRO_THROW_EXCEPTION_WITH_CODE(Exception, "", ERR_INDEX_OUT_OF_BOUNDS); mControlStatusVec[aIndex].mClass = aClass; break; case(DT_SETPOINT_STATUS): if(aIndex >= mSetpointStatusVec.size()) MACRO_THROW_EXCEPTION_WITH_CODE(Exception, "", ERR_INDEX_OUT_OF_BOUNDS); mSetpointStatusVec[aIndex].mClass = aClass; break; default: MACRO_THROW_EXCEPTION(ArgumentException, "Class cannot be assigned for this type"); } }
size_t ObjectReadIterator::CalcObjSize(const uint8_t* apPrefixPos) { if(!mHasData) return 0; switch(mHeaderInfo.GetQualifier()) { case(QC_1B_VCNT_1B_SIZE): return UInt8::Read(apPrefixPos); case(QC_1B_VCNT_2B_SIZE): return UInt16LE::Read(apPrefixPos); case(QC_1B_VCNT_4B_SIZE): return UInt32LE::Read(apPrefixPos); default: //for all other types, the size should be static or collective switch(mHeaderInfo.GetObjectType()) { case(OT_FIXED): return static_cast<const FixedObject*>(mHeaderInfo.GetBaseObject())->GetSize(); case(OT_BITFIELD): return static_cast<const BitfieldObject*>(mHeaderInfo.GetBaseObject())->GetSize(mHeaderInfo.GetCount()); default: break; } MACRO_THROW_EXCEPTION(Exception, "Invalid object type for non-sized prefix"); } }
bool EnhancedVtoRouter::CheckIncomingVtoData(const VtoData& arData) { switch(arData.GetType()) { case(VTODT_DATA): if(mInstRemoteConnected) return true; else { LOG_BLOCK(LEV_WARNING, "Discarding received data, because remote side is offline"); this->HandleReceivingDataWhenRemoteClosed(); return false; } case(VTODT_REMOTE_OPENED): if(mInstRemoteConnected) { LOG_BLOCK(LEV_WARNING, "Remote side opened, but it was already open"); this->HandleDuplicateOpen(); return false; } else { mInstRemoteConnected = true; return true; } case(VTODT_REMOTE_CLOSED): if(mInstRemoteConnected) { mInstRemoteConnected = false; return true; } else { LOG_BLOCK(LEV_WARNING, "Remote side closed, but it was already closed"); this->HandleDuplicateClose(); return false; } default: MACRO_THROW_EXCEPTION(ArgumentException, "Unknown VtoData type"); } }
void ShiftableBuffer::AdvanceRead(size_t aNumBytes) { if(aNumBytes > this->NumReadBytes()) { MACRO_THROW_EXCEPTION(ArgumentException, "Cannot be greater than the number of currently available reader bytes"); } mReadPos += aNumBytes; }
void ShiftableBuffer::AdvanceWrite(size_t aNumBytes) { if(aNumBytes > this->NumWriteBytes()) // This could indicate a buffer overflow MACRO_THROW_EXCEPTION(ArgumentException, "Cannot be greater than the number of currently available writer bytes"); mWritePos += aNumBytes; }
size_t Database::MaxIndex(DataTypes aType) { size_t num = NumType(aType); if(num == 0) { MACRO_THROW_EXCEPTION(ArgumentException, "No points for datatype"); } else return (num - 1); }
ITimer* ASIOExecutor::Start(const timer_clock::time_point& arTime, const function<void ()>& arCallback) { std::lock_guard<std::mutex> lock(mMutex); if(mIsShuttingDown) MACRO_THROW_EXCEPTION(InvalidStateException, "Can't start a timer while executor is shutting down"); TimerASIO* pTimer = GetTimer(); pTimer->mTimer.expires_at(arTime); this->StartTimer(pTimer, arCallback); return pTimer; }
StreamObject<Binary>* SlaveResponseTypes::GetStaticBinary(StaticBinaryResponse rsp) { switch(rsp) { case(SBR_GROUP1_VAR2): return Group1Var2::Inst(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid static binary"); } }
Type Property::get(const string& key) const { if(!exist_(key)) { string msg = (boost::format("key \"%s\" not found in property file: %s") % key % fileName_).str(); flow::exception::Parse e; MACRO_THROW_EXCEPTION(e, msg) e; } Type val; try { val = cast_<Type>( dataMap_.find(key)->second ); } catch (flow::exception::Parse& e) { string msg = (boost::format("key : \"%s\"") % key).str(); MACRO_THROW_EXCEPTION(e, msg); } return val; }
StreamObject<Binary>* SlaveResponseTypes::GetEventBinary(EventBinaryResponse rsp) { switch(rsp) { case(EBR_GROUP2_VAR1): return Group2Var1::Inst(); case(EBR_GROUP2_VAR2): return Group2Var2::Inst(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid event binary"); } }
StreamObject<Counter>* SlaveResponseTypes::GetStaticCounter(StaticCounterResponse rsp) { switch(rsp) { case(SCR_GROUP20_VAR1): return Group20Var1::Inst(); case(SCR_GROUP20_VAR2): return Group20Var2::Inst(); case(SCR_GROUP20_VAR5): return Group20Var5::Inst(); case(SCR_GROUP20_VAR6): return Group20Var6::Inst(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid static counter"); } }
StreamObject<SetpointStatus>* SlaveResponseTypes::GetStaticSetpointStatus(StaticSetpointStatusResponse rsp) { switch(rsp) { case(SSSR_GROUP40_VAR1): return Group40Var1::Inst(); case(SSSR_GROUP40_VAR2): return Group40Var2::Inst(); case(SSSR_GROUP40_VAR3): return Group40Var3::Inst(); case(SSSR_GROUP40_VAR4): return Group40Var4::Inst(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid static analog output status"); } }
void AsyncTaskBase::OnComplete(bool aSuccess) { if(!mIsRunning) { MACRO_THROW_EXCEPTION(InvalidStateException, "Not Running"); } mIsRunning = false; this->_OnComplete(aSuccess); mpGroup->OnCompletion(); }
const ObjectWriteIterator& ObjectWriteIterator::operator++() { if(this->IsEnd()) { MACRO_THROW_EXCEPTION(InvalidStateException, "End of iterattion"); } ++mIndex; mpPos += mObjectSize; return (*this); }
StreamObject<Counter>* SlaveResponseTypes::GetEventCounter(EventCounterResponse rsp) { switch(rsp) { case(ECR_GROUP22_VAR1): return Group22Var1::Inst(); case(ECR_GROUP22_VAR2): return Group22Var2::Inst(); case(ECR_GROUP22_VAR5): return Group22Var5::Inst(); case(ECR_GROUP22_VAR6): return Group22Var6::Inst(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid event counter"); } }
bool ShiftableBuffer::Sync(const uint8_t* apPattern, size_t aNumBytes) { if(aNumBytes < 1) { MACRO_THROW_EXCEPTION(ArgumentException, "Pattern must be at least 1 byte"); } size_t offset = SyncSubsequence(apPattern, aNumBytes, 0); bool res = (this->NumReadBytes() - offset) >= aNumBytes; if(offset > 0) this->AdvanceRead(offset); return res; }
StreamObject<Analog>* SlaveResponseTypes::GetStaticAnalog(StaticAnalogResponse rsp) { switch(rsp) { case(SAR_GROUP30_VAR1): return Group30Var1::Inst(); case(SAR_GROUP30_VAR2): return Group30Var2::Inst(); case(SAR_GROUP30_VAR3): return Group30Var3::Inst(); case(SAR_GROUP30_VAR4): return Group30Var4::Inst(); case(SAR_GROUP30_VAR5): return Group30Var5::Inst(); case(SAR_GROUP30_VAR6): return Group30Var6::Inst(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid static analog"); } }
bool Property::cast_<bool>(const string& valStr) const { string val = boost::to_lower_copy(valStr); if(val == "true") return true; if(val == "false") return false; // true(TRUE) false(FALSE) 以外では例外を投げる string msg = "true(TREU) or false(FALSE) is allowed as bool type value"; flow::exception::Parse e; MACRO_THROW_EXCEPTION(e, msg) e; }
Type Property::cast_(const string& valStr) const { Type val; try { val = boost::lexical_cast<Type>( valStr ); } catch(boost::bad_lexical_cast& e0) { string msg = (boost::format("value \"%s\" is inconpatible with type of %s") % valStr % string(typeid(Type).name())).str(); flow::exception::Parse e; MACRO_THROW_EXCEPTION(e, msg) e; } return val; }
UbVectorD Property::get(const string& key, const UbVectorD& defaultVal) const { if(!exist_(key)) return defaultVal; UbVectorD val; try { val = cast_<UbVectorD>( dataMap_.find(key)->second ); } catch (flow::exception::Parse& e) { string msg = (boost::format("key : \"%s\"") % key).str(); MACRO_THROW_EXCEPTION(e, msg); } return val; }
void PhysicalLayerAsyncBase::AsyncRead(uint8_t* apBuff, size_t aMaxBytes) { if(aMaxBytes < 1) { MACRO_THROW_EXCEPTION(ArgumentException, "aMaxBytes must be > 0"); } if(mState.CanRead()) { mState.mReading = true; this->DoAsyncRead(apBuff, aMaxBytes); } else { MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "AsyncRead: " << this->ConvertStateToString()); } }
void PhysicalLayerAsyncBase::AsyncWrite(const uint8_t* apBuff, size_t aNumBytes) { if(aNumBytes < 1) { MACRO_THROW_EXCEPTION(ArgumentException, "aNumBytes must be > 0"); } if(mState.CanWrite()) { mState.mWriting = true; this->DoAsyncWrite(apBuff, aNumBytes); } else { MACRO_THROW_EXCEPTION_COMPLEX(InvalidStateException, "AsyncWrite: " << this->ConvertStateToString()); } }
size_t SlaveEventBuffer::Select(BufferTypes aType, PointClass aClass, size_t aMaxEvent) { switch(aType) { case BT_BINARY: return mBinaryEvents.Select(aClass, aMaxEvent); case BT_ANALOG: return mAnalogEvents.Select(aClass, aMaxEvent); case BT_COUNTER: return mCounterEvents.Select(aClass, aMaxEvent); case BT_VTO: return mVtoEvents.Select(aClass, aMaxEvent); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid BufferType"); } }
UbVectorD Property::cast_<UbVectorD>(const string& valStr) const { string val = boost::to_lower_copy(valStr); // valStr をspaceでsplit UbVectorD vec; //vecの要素数をsplitで分割した数にあわせる try { // 要素をセット return vec; } catch(boost::bad_lexical_cast& e0) { flow::exception::Parse e; MACRO_THROW_EXCEPTION(e, "") e; } }
StreamObject<Analog>* SlaveResponseTypes::GetEventAnalog(EventAnalogResponse rsp) { switch(rsp) { case(EAR_GROUP32_VAR1): return Group32Var1::Inst(); case(EAR_GROUP32_VAR2): return Group32Var2::Inst(); case(EAR_GROUP32_VAR3): return Group32Var3::Inst(); case(EAR_GROUP32_VAR4): return Group32Var4::Inst(); case(EAR_GROUP32_VAR5): return Group32Var5::Inst(); case(EAR_GROUP32_VAR6): return Group32Var6::Inst(); case(EAR_GROUP32_VAR7): return Group32Var7::Inst(); case(EAR_GROUP32_VAR8): return Group32Var8::Inst(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid event analog"); } }
size_t SlaveEventBuffer::NumType(BufferTypes aType) { switch(aType) { case BT_BINARY: return mBinaryEvents.Size(); case BT_ANALOG: return mAnalogEvents.Size(); case BT_COUNTER: return mCounterEvents.Size(); case BT_VTO: return mVtoEvents.Size(); default: MACRO_THROW_EXCEPTION(ArgumentException, "Invalid BufferType"); } }
void Database::SetDeadband(DataTypes aType, size_t aIndex, double aDeadband) { switch(aType) { case(DT_ANALOG): if(aIndex >= mAnalogVec.size()) MACRO_THROW_EXCEPTION_WITH_CODE(Exception, "", ERR_INDEX_OUT_OF_BOUNDS); mAnalogVec[aIndex].mDeadband = aDeadband; break; case(DT_COUNTER): if(aIndex >= mCounterVec.size()) MACRO_THROW_EXCEPTION_WITH_CODE(Exception, "", ERR_INDEX_OUT_OF_BOUNDS); mCounterVec[aIndex].mDeadband = aDeadband; break; default: MACRO_THROW_EXCEPTION(ArgumentException, "Deadband cannot be assigned for this type"); } }