pred_decoder.h

Go to the documentation of this file.

/*  This file is part of OMCSNetCPP

    OMCSNetCPP is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.

    OMCSNetCPP is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with OMCSNetCPP; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _PRED_DECODER

#define _PRED_DECODER

#include <string>

#include "qstring.h"
#include "qregexp.h"

#include "concept.h"
#include "concept_map.h"
#include "textid_map.h"
#include "id_generator.h"
#include "relation_type.h"
#include "link_map.h"
#include "debug.h"


class CPredicateDecoder
{
        public:
                void DecodePredicateText(const std::string          &a_string,
                                               CTextIDMap           &a_idMap,
                                               CSemanticIDGenerator &a_idGen,
                                               CConceptMap          &a_conceptMap,
                                               CLinkMap             &a_linkMap)
                {
                        QRegExp l_regex("\\((\\w+)\\s+\\\"(.+)\\\"\\s+\\\"(.+)\\\"");

                        if (l_regex.search(a_string) >= 0)
                        {
                                QString l_relationship;
                                QString l_source;
                                QString l_destination;

                                l_relationship     = l_regex.cap(1);
                                l_source           = l_regex.cap(2);
                                l_destination      = l_regex.cap(3);

                                RelationType l_relationType;

                                l_relationType = m_relationLookup.Lookup(
                                                        l_relationship);

                                SemanticID l_sourceID;

                                l_sourceID = a_idMap.Lookup(l_source);

                                CSemanticConcept *l_srcConcept = NULL;

                                if (SEMANTIC_ID_NONE == l_sourceID)
                                {
                                        l_srcConcept = new CSemanticConcept(
                                                                    l_source,
                                                                    &a_idGen,
                                                                    &a_idMap);

                                        a_conceptMap.Store(l_srcConcept);

                                        DPRINT("storing %s %d.\n",
                                                l_source.ascii(),
                                                l_relationType);

                                        l_sourceID = l_srcConcept->GetID();
                                }
                                else
                                {
                                        l_srcConcept =
                                                a_conceptMap.Lookup(l_sourceID);
                                }

                                SemanticID l_destinationID;

                                l_destinationID = a_idMap.Lookup(l_destination);

                                CSemanticConcept *l_dstConcept = NULL;

                                if (SEMANTIC_ID_NONE == l_destinationID)
                                {
                                        l_dstConcept = new CSemanticConcept(
                                                                 l_destination,
                                                                 &a_idGen,
                                                                 &a_idMap);

                                        a_conceptMap.Store(l_dstConcept);

                                        DPRINT("storing %s %d.\n",
                                                l_destination.ascii(),
                                                l_relationType);

                                        l_destinationID = l_dstConcept->GetID();
                                }
                                else
                                {
                                        l_dstConcept =
                                           a_conceptMap.Lookup(l_destinationID);
                                }

                                CSemanticLink *l_link = NULL;

                                DPRINT("storing link\n");

                                l_link = new CSemanticLink();
                                                        
                                l_link->SetSource(l_srcConcept);
                                l_link->SetDest(l_dstConcept);

                                l_link->SetType(l_relationType);

                                l_link->SetID(a_idGen.Get());

                                a_linkMap.Store(l_link);

                                DPRINT("storing forward lnk\n");

                                l_srcConcept->AddLink(l_link,
                                                        l_relationType);

                                DPRINT("storing bckward lnk\n");

                                l_dstConcept->AddBackwardLink(
                                                l_link, l_relationType);
                        }
                }

                CPredicateDecoder() {}

                ~CPredicateDecoder() {}

        private:
                CRelationTypeLookup m_relationLookup;
};

#endif

---