Exemple #1
0
    void BehaviorTask::load(ISerializableNode* node)
    {
        CSerializationID  attrId("status");
        behaviac::string attrStr;

        if (node->getAttr(attrId, attrStr))
        {
            behaviac::StringUtils::FromString(attrStr.c_str(), this->m_status);
        }

#if !BEHAVIAC_RELEASE

        if (this->m_status != BT_INVALID)
        {
            CSerializationID  classId("class");
            node->getAttr(classId, attrStr);
            BEHAVIAC_ASSERT(attrStr == this->GetClassNameString());

            CSerializationID  idId("id");
            node->getAttr(idId, attrStr);
            int id = -1;
            StringUtils::FromString(attrStr.c_str(), id);
            BEHAVIAC_ASSERT(id == this->GetId());
        }

#endif
    }
Exemple #2
0
    XmlNodeRef State_t::SaveToXmlNode(Agent* pAgent) const
    {
        XmlNodeRef xmlInfo = CreateXmlNode("AgentState");

        CTextNode node(xmlInfo);

        CSerializationID  attrId("agentType");
        node.setAttr(attrId, this->m_agentType);

        if (pAgent)
        {
            CSerializationID  membersId("members");
            ISerializableNode* membersNode = node.newChild(membersId);
            pAgent->Save(membersNode);
        }

        this->m_vars.Save(&node);

        if (this->m_bt)
        {
            this->m_bt->Save(&node);
        }

        return xmlInfo;
    }
Exemple #3
0
    void CompositeTask::load(ISerializableNode* node)
    {
        super::load(node);

        if (this->m_status != BT_INVALID)
        {
            CSerializationID attrId("activeChildIndex");
            behaviac::string attrStr;
            node->getAttr(attrId, attrStr);
            StringUtils::FromString(attrStr.c_str(), this->m_activeChildIndex);

            //#if !BEHAVIAC_RELEASE
            //			if (this->m_activeChildIndex != uint32_t(-1))
            //			{
            //				BEHAVIAC_ASSERT(this->m_currentTask == this->m_children[this->m_activeChildIndex]);
            //			}
            //			else
            //			{
            //				BEHAVIAC_ASSERT(this->m_currentTask == 0);
            //			}
            //#endif

            BehaviorTasks_t::size_type count = this->m_children.size();
            BEHAVIAC_ASSERT(count == (BehaviorTasks_t::size_type)node->getChildCount());

            for (BehaviorTasks_t::size_type i = 0; i < count; ++i)
            {
                BehaviorTask* childTask = this->m_children[i];

                //CSerializationID  nodeId("node");
                ISerializableNode* chidlNode = node->getChild(i);
                childTask->load(chidlNode);
            }
        }
    }
void CBuilderAdapterVisitor::VisitAttributeL(CSdpAttr &aAttribute)
	{
	if(!iBuilder)
		return;
	TBuf8<2> attrId(2);
	BigEndian::Put16(&attrId[0], aAttribute.AttributeID());
	iBuilder = iBuilder->BuildUintL(attrId);
	}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::RemoveIdentityFromManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::RemoveIdentityFromManyExceptL(
    const TDesC& aRuleID, const TDesC& aId, const TDesC& aDomain)
{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::RemoveIdentityFromManyExceptL()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID:%S,aDomain:%S,aId:%S"),
             &aRuleID, &aDomain, &aId);

    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));

    TInt ret(KErrNotFound);

    RPointerArray<CXdmDocumentNode> nodes;
    CXdmNodeAttribute* attrId(NULL);


    CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
    if(manyNode!=NULL)
    {
        TInt err = manyNode->Find(KXdmExcept, nodes);
        TInt exceptNodeCount = nodes.Count();

        //go through all except nodes
        for (TInt i=0; i<exceptNodeCount; i++)
        {
            attrId = (nodes[i])->Attribute(KXdmId);

            // for now we are supposing that except has only 1 id
            if(attrId!=NULL)
            {
                if (aId==(attrId->AttributeValue()))
                {
                    OPENG_DP(D_OPENG_LIT( "     RemoveFromModelL: i=%d" ),i);
                    iPresXDM->RemoveFromModelL(attrId);

                    //if except node is empty after this
                    if( (nodes[i])->AttributeCount() == 0)
                    {
                        // remove except node also
                        iPresXDM->RemoveFromModelL(nodes[i]);
                    }
                    ret = KErrNone;
                    break;
                }
            }
            attrId = NULL;
        }
    }

    OPENG_DP(D_OPENG_LIT( "     return: %d"),ret);
    nodes.Close();
    return ret;
}
Exemple #6
0
    void BranchTask::save(ISerializableNode* node) const
    {
        super::save(node);

        if (this->m_status != BT_INVALID)
        {
            int id = -1;

            if (this->m_currentTask)
            {
                id = this->m_currentTask->GetId();
            }

            CSerializationID attrId("current");
            node->setAttr(attrId, id);
        }
    }
Exemple #7
0
    void BranchTask::load(ISerializableNode* node)
    {
        super::load(node);

        if (this->m_status != BT_INVALID)
        {
            CSerializationID  attrId("current");
            behaviac::string attrStr;

            if (node->getAttr(attrId, attrStr))
            {
                int currentNodeId = -1;
                StringUtils::FromString(attrStr.c_str(), currentNodeId);

                if (currentNodeId != -1)
                {
                    this->m_currentTask = (BehaviorTask*)this->GetTaskById(currentNodeId);
                }
            }
        }
    }
Exemple #8
0
    void CompositeTask::save(ISerializableNode* node) const
    {
        super::save(node);

        if (this->m_status != BT_INVALID)
        {
            CSerializationID attrId("activeChildIndex");
            node->setAttr(attrId, this->m_activeChildIndex);

            BehaviorTasks_t::size_type count = this->m_children.size();

            for (BehaviorTasks_t::size_type i = 0; i < count; ++i)
            {
                BehaviorTask* childTask = this->m_children[i];

                CSerializationID  nodeId("node");
                ISerializableNode* chidlNode = node->newChild(nodeId);
                childTask->save(chidlNode);
            }
        }
    }
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::IsIdentityExistsInManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TBool TPresCondIdentityMany::IsIdentityExistsInManyExceptL(const TDesC& aRuleID,
        const TDesC& aId, const TDesC& aDomain)
{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::IsIdentityExistsInManyExcept()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID:%S,aDomain:%S,aId:%S"),
             &aRuleID, &aDomain, &aId);

    TBool ret(EFalse);
    RPointerArray<CXdmDocumentNode> nodes;
    CXdmNodeAttribute* attrId(NULL);

    CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
    if(manyNode!=NULL)
    {
        TInt err = manyNode->Find(KXdmExcept, nodes);
        TInt exceptNodeCount = nodes.Count();

        //go through all except nodes
        for (TInt i=0; i<exceptNodeCount; i++)
        {
            attrId = (nodes[i])->Attribute(KXdmId);

            // for now we are supposing that except has only 1 id
            if(attrId!=NULL)
            {
                if (aId==(attrId->AttributeValue()))
                {
                    OPENG_DP(D_OPENG_LIT( "     Found: i=%d" ),i);
                    ret = ETrue;
                    break;
                }
            }
            attrId = NULL;
        }
    }

    nodes.Close();
    return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::GetIdentitiesFromManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::GetIdentitiesFromManyExceptL(const TDesC& aRuleID,
        CDesCArray& aIds, const TDesC& aDomain)
{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::GetIdentitiesFromManyExceptL()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID:%S,aDomain:%S"),&aRuleID, &aDomain);

    TInt ret(KErrNotFound);

    RPointerArray<CXdmDocumentNode> nodes;
    CXdmNodeAttribute* attrId(NULL);

    CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
    if(manyNode!=NULL)
    {
        TInt err = manyNode->Find(KXdmExcept, nodes);
        TInt exceptNodeCount = nodes.Count();

        // go through all 'except' nodes
        for(TInt i=0; i<exceptNodeCount; i++)
        {
            attrId = (nodes[i])->Attribute(KXdmId);

            // for now we are supposing that except has only 1 id
            if(attrId!=NULL)
            {
                aIds.AppendL(attrId->AttributeValue());
            }
            attrId = NULL;
        }
        ret = KErrNone;
    }

    OPENG_DP(D_OPENG_LIT( "     return: %d"),ret);
    nodes.Close();
    return ret;
}