AILogic.h

Go to the documentation of this file.

//    Copyright (C) 2004-2007 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library 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.
//
//    This library 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 this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef AILOGIC_H
#define AILOGIC_H

#include "AIFSM.h"
#include "AIKB.h"

namespace OpenSkyNet {
    namespace AI {
        extern KB* g_kB;

        class Logic {
        public:
            //I would prefer Rule to be private, but I don't know how to make it accessible 
            //for the explicitly instantiated versions of FileIO::serialize and 
            //FileIO::assemble declared below.
            struct Rule {
                std::vector<Premise> _antecedents;
                std::vector<int> _numOfParamsInAntecsToCheck;
                int _consequentStateInput;
                std::vector<int> _timesFound;
                std::vector<bool> _acceptOnlyNewSinceStateChange;
                std::vector<float> _secondsOld; 
                std::vector<Premise> _conseKBPrems;
                std::vector<Premise> _remKBPrems;
                std::vector<bool> _remAll; 

                int serialize(std::ofstream& fout_) const;
                int assemble(std::ifstream& fin_);
            };
        private:
            LOGIC_IDS _logicId;
            std::vector<Rule> _rules;
            int _maxRules;

            void checkPremises(const std::list<Record>& premsToCheck_, int& antecIndex_, float& timeStamp_);

            bool antecCheck, allAntecsCheck, doChangeState, ruleCheck, returnVal;
            int countFound, findThisMany, rulesSize, premsSize, stateInputsSize;
            int*  stateInput;
            float currTime;
            Rule* currRule;
            Premise* currPrem;
            Record record;
        public:
            Logic(LOGIC_IDS logicId_, const int maxRules_=-1);

            inline LOGIC_IDS getLogicId() const { return _logicId; }

            bool createDerivationRule(const std::vector<Premise>& antecedents_, 
                const std::vector<int>& numOfParamsInAntecsToCheck_, 
                int consequentStateInput_, 
                const std::vector<int>& timesFound_, 
                const std::vector<bool>& acceptOnlyNewSinceStateChange_, 
                const std::vector<float>& secondsOld_, 
                const std::vector<Premise>& conseKBPrems_, 
                const std::vector<Premise>& remKBPrems_, 
                const std::vector<bool>& remAll_);

            bool performLogic(State*& state_, KB*& kB_, float& timeStamp_, 
                bool includeGlobalKB_=false); 

            int serialize(std::ofstream& fout_) const;

            int assemble(std::ifstream& fin_);
        };

        namespace FileIO {
            template <>
            int serialize(std::ofstream& fout_, const std::vector<Logic::Rule>& ruleVector_);

            template <>
            int assemble(std::ifstream& fin_, std::vector<Logic::Rule>& ruleVector_);
        }
    }
}

#endif //AILOGIC_H