AIBase.h

Go to the documentation of this file.

//      Copyright (C) 2004 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 AIBASE_H
#define AIBASE_H

#include "AIConsts.h"

class AIPremise {
public:
        std::vector<int> params; 
        float entrytime;         
        bool negated;            

        AIPremise(std::vector<int> params_=std::vector<int>());

        virtual bool operator==(const AIPremise& rhs) const;

        virtual bool equals(const AIPremise& rhs, int numparamstocheck_) const;

        AIPremise& operator=(int param_) {
                params.clear();
                params.push_back(param_);
                entrytime = -1.0f;
                negated = false;
                return *this;
        }

        AIPremise& operator+=(int param_) {
                params.push_back(param_);
                return *this;
        }

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

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

        virtual ~AIPremise() {} 
};

class AIAction : public AIPremise {
public:
        AIAction(std::vector<int> params_=std::vector<int>());

        AIAction& operator=(int param_) {
                AIPremise::operator=(param_);
                return *this;
        }

        AIAction& operator+=(int param_) {
                AIPremise::operator+=(param_);
                return *this;
        }

        virtual ~AIAction() {} 
};

class AIWrapper;

class AIException : public AIPremise {
public:
        AIWrapper* n;               
        float badgoodscalevalue;    
        int stateIDduringexception; 

        AIException(std::vector<int> params_=std::vector<int>(), AIWrapper* n_=0, float badgoodscalevalue_=0.0f,
                int stateIDduringexception_=-1);

        AIException& operator=(int param_) {
                AIPremise::operator=(param_);
                return *this;
        }

        AIException& operator+=(int param_) {
                AIPremise::operator+=(param_);
                return *this;
        }

        virtual ~AIException() {} 
};

namespace AIFileIO {
        template <class T>
        int serialize(std::ofstream& fout_, const std::vector<T>& vector_) {
                static const unsigned int sizeoftype = sizeof(T);
                unsigned int byteswritten = 0;
                unsigned int vectorsize = vector_.size();
                
                fout_.write((char*)&vectorsize,sizeoftype);
                byteswritten += sizeoftype;

                for (int i = 0; i < vectorsize; i++)
                        fout_.write((char*)&(vector_[i]),sizeoftype);
                byteswritten += vectorsize*sizeoftype;

                return byteswritten;
        }

        template <class T>
        int assemble(std::ifstream& fin_, std::vector<T>& vector_) {
                static const unsigned int sizeoftype = sizeof(T);
                unsigned int bytesread = 0;
                unsigned int vectorsize = 0;
                vector_.clear();

                fin_.read((char*)&vectorsize,sizeoftype);
                bytesread += sizeoftype;

                vector_.resize(vectorsize);
                for (int i = 0; i < vectorsize; i++)
                        fin_.read((char*)&(vector_[i]),sizeoftype);
                bytesread += vectorsize*sizeoftype;

                return bytesread;
        }

        template <>
        int serialize(std::ofstream& fout_, const std::vector<AIPremise>& premVector_);

        template <>
        int assemble(std::ifstream& fin_, std::vector<AIPremise>& premVector_);

        template <>
        int serialize(std::ofstream& fout_, const std::vector<AIAction>& actVector_);

        template <>
        int assemble(std::ifstream& fin_, std::vector<AIAction>& actVector_);
}

#endif //AIBASE_H

---