Exemple #1
0
IKeyboard::AddHotKeyResult RDOKeyboard::addHotKey(const LPRDORuntime& pRuntime, const std::string& hotKey)
{
    RDOHotKey::KeyCode scanCode = pRuntime->hotkey().toolkit().codeFromString(hotKey);
    if (scanCode   == RDOHotKey::UNDEFINED_KEY)
        return IKeyboard::AddHotKeyResult::NOTFOUND;
    if (m_scan_code != RDOHotKey::UNDEFINED_KEY && scanCode != VK_SHIFT && scanCode != VK_CONTROL)
        return IKeyboard::AddHotKeyResult::ALREADY;
    switch (scanCode)
    {
    case VK_SHIFT:
        m_shift = true;
        pRuntime->hotkey().keyInModel().insert(VK_SHIFT);
        break;
    case VK_CONTROL:
        m_control = true;
        pRuntime->hotkey().keyInModel().insert(VK_CONTROL);
        break;
    default:
        m_scan_code = scanCode;
        if (m_scan_code)
        {
            pRuntime->hotkey().keyInModel().insert(scanCode);
        }
        break;
    }
    return IKeyboard::AddHotKeyResult::OK;
}
bool RDOPROCSeize::onCheckCondition(const LPRDORuntime& pRuntime)
{
	if (m_transacts.empty())
		return false;

	const std::size_t Size_Seizes = forRes.size();
	for (std::size_t i = 0; i < Size_Seizes; i++)
	{
		// если свободен
		if (forRes[i].rss->getParam(forRes[i].Id_param) == forRes[i].enum_free)
		{
			const std::size_t idBlocksTransact = m_transacts.front()->getTraceID();
			const std::size_t idResourcesTransact = forRes[i].rss->transacts.front()->getTraceID();
			if (idBlocksTransact != idResourcesTransact)
				return false;

			RDOTrace* tracer = pRuntime->getTracer();
			forRes[i].rss->setParam(forRes[i].Id_param, forRes[i].enum_buzy);
			TRACE3("%7.1f SEIZES-%d, resId = %d\n", pRuntime->getCurrentTime(), index, forRes[i].rss->getTraceID());
			if (!tracer->isNull())
				tracer->getOStream() << forRes[i].rss->traceResourceState('\0', pRuntime) << tracer->getEOL();

			m_transacts.front()->setRes(forRes[i].rss);
			return true;
		}
	}
	return false;
}
Exemple #3
0
bool RDOKeyboard::choiceFrom(const LPRDORuntime& pRuntime)
{
    pRuntime->setCurrentActivity(this);

    if (!pRuntime->hotkey().areaList().check(m_oprName))
    {
        if (!pRuntime->hotkey().keyDown().isPressed(m_scan_code, m_shift, m_control))
            return false;
    }
    return RDOOperation::choiceFrom(pRuntime);
}
Exemple #4
0
LPRDORuntime RDORuntime::clone() const
{
    LPRDORuntime pRuntime = rdo::Factory<RDORuntime>::create(m_pError);
    ASSERT(pRuntime);
    pRuntime->m_sizeofSim = sizeof(RDORuntime);

    LPRDORuntime pThis(const_cast<RDORuntime*>(this));
    pRuntime->copyFrom(pThis);

    return pRuntime;
}
Exemple #5
0
// --------------------------------------------------------------------------------
// -------------------- RDOFunCalcNotExist
// --------------------------------------------------------------------------------
RDOValue RDOFunCalcNotExist::doCalc(const LPRDORuntime& pRuntime)
{
	bool res = true;
	RDORuntime::ResCIterator end = pRuntime->getResType(m_nResType)->res_end();
	for (RDORuntime::ResCIterator it = pRuntime->getResType(m_nResType)->res_begin(); it != end && res; it++)
	{
		if (*it == LPRDOResource(NULL))
			continue;

		pRuntime->pushGroupFunc(*it);
		if (m_pCondition->calcValue(pRuntime).getAsBool())
			res = false;
		pRuntime->popGroupFunc();
	}
	return RDOValue(res);
}
void RDOPROCBlockForQueue::_onStart(const LPRDORuntime& pRuntime)
{
	int Id_res = fromParser.Id_res;
	int Id_param = fromParser.Id_param;
	LPRDOResource res = pRuntime->getResourceByID(Id_res);
	forRes.Id_param = Id_param;
	forRes.rss = res.object_static_cast<RDOPROCResource>();
	forRes.defaultValue = RDOValue(RDOPROCQueue::getDefaultValue());
}
bool RDOPROCRelease::onCheckCondition(const LPRDORuntime& pRuntime)
{
	if (!m_transacts.empty())
	{
		int Size_Seizes = forRes.size();
		for(int i=0;i<Size_Seizes; i++)
		{
			if(forRes[i].rss == m_transacts.front()->getRes())
			{
				// Занят
				if (forRes[i].rss->getParam(forRes[i].Id_param) == forRes[i].enum_buzy)
				{
					RDOTrace* tracer = pRuntime->getTracer();
					TRACE3("%7.1f RELEASES-%d, resId = %d\n", pRuntime->getCurrentTime(), index, forRes[i].rss->getTraceID());
					forRes[i].rss->setParam(forRes[i].Id_param, forRes[i].enum_free);
					if (!tracer->isNull())
					{
						tracer->getOStream() << forRes[i].rss->traceResourceState('\0', pRuntime) << tracer->getEOL();
					}				
					return true;
				}		
				// Не Занят и не свободен
				if (forRes[i].rss->getParam(forRes[i].Id_param) != forRes[i].enum_free)
				{
					//Удаляем транзакт
					RDOTrace* tracer = pRuntime->getTracer();
					TRACE3("%7.1f RELEASES_Bad-%d, resId = %d\n", pRuntime->getCurrentTime(), index, forRes[i].rss->getTraceID());
					LPRDOPROCTransact transact = m_transacts.front();
					ASSERT(transact);
					transact->setState(RDOResource::CS_Erase);
					if (!tracer->isNull())
					{
						tracer->getOStream() << transact->traceResourceState('\0', pRuntime) << tracer->getEOL();
					}
					m_transacts.remove(transact);
					forRes[i].rss->transacts.remove(transact);
					pRuntime->onEraseRes(transact->getTraceID(), NULL);
					return false;
				}
			}
		}
	}
	return false;
}
Exemple #8
0
RDOValue RDOCalcFunctionCaller::doCalc(const LPRDORuntime& pRuntime)
{
    pRuntime->pushFuncTop();
    for (const auto& param: m_paramList)
    {
        pRuntime->pushFuncArgument(param->calcValue(pRuntime));
    }
    pRuntime->resetFuncTop(m_paramList.size());

    RDOValue value = m_pFunction->calcValue(pRuntime);

    for (std::size_t i = 0; i < m_paramList.size(); ++i)
    {
        pRuntime->popFuncArgument();
    }
    pRuntime->popFuncTop();

    return value;
}
Exemple #9
0
// --------------------------------------------------------------------------------
// -------------------- RDOFunCalcForAll
// --------------------------------------------------------------------------------
RDOValue RDOFunCalcForAll::doCalc(const LPRDORuntime& pRuntime)
{
	bool first_found = false;
	bool res = true;
	RDORuntime::ResCIterator end = pRuntime->getResType(m_nResType)->res_end();
	for (RDORuntime::ResCIterator it = pRuntime->getResType(m_nResType)->res_begin(); it != end && res; it++)
	{
		if (*it == LPRDOResource(NULL))
			continue;

		pRuntime->pushGroupFunc(*it);
		if (!m_pCondition->calcValue(pRuntime).getAsBool())
		{
			res = false;
		}
		else if (!first_found)
		{
			first_found = true;
		}
		pRuntime->popGroupFunc();
	}
	return RDOValue(first_found ? res : false);
}
Exemple #10
0
OPEN_RDO_RUNTIME_NAMESPACE

// --------------------------------------------------------------------------------
// -------------------- RDODPTSearchRuntime
// --------------------------------------------------------------------------------
RDODPTSearchRuntime::RDODPTSearchRuntime(const LPRDORuntime& pRuntime, LPIBaseOperationContainer parent, const LPRDOCalc& _pCondition, const LPRDOCalc& _pTermCondition, const LPRDOCalc& _pEvaluateBy, bool _compTops, RDODPTSearchTrace::TraceFlag _traceFlag)
    : RDODPTSearchTrace(pRuntime, parent)
    , pCondition       (_pCondition     )
    , pTermCondition   (_pTermCondition )
    , pEvaluateBy      (_pEvaluateBy    )
    , compTops         (_compTops       )
{
    setTraceID(pRuntime->getFreeDPTId());
    traceFlag = _traceFlag;
}
Exemple #11
0
RDOValue RDOFunAlgorithmicCalc::doCalc(const LPRDORuntime& pRuntime)
{
    RDOCalcList::const_iterator actionIt = m_actionList.begin();
    for (const auto& condition: m_conditionList)
    {
        if (condition->calcValue(pRuntime).getAsBool())
        {
            return (*actionIt)->calcValue(pRuntime);
        }
        ++actionIt;
    }

    // До сюда дело дойти не должно, т.к. последний conditions должен быть значением по молчанию
    pRuntime->error().push("Внутренняя ошибка, RDOFunAlgorithmicCalc", srcInfo());
    return RDOValue();
}
void RDOPROCBlockForSeize::_onStart(const LPRDORuntime& pRuntime)
{
	/// @todo: если потребуется стоить деревья, вершинами которых будут полные снимки БД,
	// как при DPT search, то инициализацию атрибутов надо будет делать в checkOperation
	std::vector<parser_for_Seize>::iterator it1 = fromParser.begin();
	while (it1 != fromParser.end())
	{
		int Id_res = (*it1).Id_res;
		int Id_param = (*it1).Id_param;
		LPRDOResource res = pRuntime->getResourceByID(Id_res);
		runtime_for_Seize bbb;
		bbb.Id_param = Id_param;
		bbb.rss = res.object_static_cast<RDOPROCResource>();
		bbb.enum_free = RDOValue(bbb.rss->getParam(Id_param).getEnum(), RDOPROCBlockForSeize::getStateEnumFree());
		bbb.enum_buzy = RDOValue(bbb.rss->getParam(Id_param).getEnum(), RDOPROCBlockForSeize::getStateEnumBuzy());
		forRes.push_back(bbb);
		++it1;
	}
}
Exemple #13
0
void RDORuntime::copyFrom(const LPRDORuntime& pOther)
{
    ASSERT(pOther);
    ASSERT(m_resourceTypeList.empty());

    LPRDORuntime pThis(const_cast<RDORuntime*>(this));

    for (const LPRDOResourceTypeList& pRTP: pOther->m_resourceTypeList)
    {
        pRTP->clone(pThis);
    }

    m_constantList         = pOther->m_constantList;
    m_patternParameterList = pOther->m_patternParameterList;
    m_resultList           = pOther->m_resultList;
    m_pThreadProxy         = pOther->m_pThreadProxy;
    setCurrentTime(pOther->getCurrentTime());

    parent_type::copyFrom(pOther.object_parent_cast<parent_type>());
}
Exemple #14
0
RDOValue RDOCalcSetConst::doCalc(const LPRDORuntime& pRuntime)
{
    pRuntime->setConstValue(m_constantID, m_pCalc->calcValue(pRuntime));
    return RDOValue();
}
Exemple #15
0
RDOValue RDOCalcGetConst::doCalc(const LPRDORuntime& pRuntime)
{
    return pRuntime->getConstValue(m_constantID);
}
Exemple #16
0
RDOValue RDOCalcFuncParam::doCalc(const LPRDORuntime& pRuntime)
{
    return pRuntime->getFuncArgument(m_paramID);
}