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");
}
}
