XPRULE.H

Go to the documentation of this file.

//: xprule.h
#if defined (__GNUG__)
    #pragma interface "xprule.h"
#endif

#ifndef xprule_h
    #define xprule_h
#include    "../include/xbool.h"

    #include <wx/wxprec.h>

    #ifdef __BORLANDC__
        #pragma hdrstop
    #endif

    #ifndef WX_PRECOMP
        #include <wx/wx.h>
    #endif


extern bool xpShortcutMode;

// Define symbolic logical operations
#ifndef AND
    #define AND &&
    #define OR ||
    #define NOT !
#endif


class xpAgent :  public wxObject
{   public:
        xpAgent()
        {}      // no functionality (yet)
};//xpAgent


class xpUserAgent :  public xpAgent
{   public:
        xpUserAgent()
        {}
};//xpUserAgent


class xpDatabaseAgent :  public xpAgent
{   public:
        xpDatabaseAgent()
        {}
};//xpDatabaseAgent

  
class   xpRuleGeneric : public xboolean
{   protected:
        wxString HistoryString;     
        xpAgent *Agent;   
        wxString    Name;           
    public:
        xpRuleGeneric(  xpAgent *MyAgent=NULL)
        :xboolean()
        {   Agent = MyAgent;  // Save the agent working for us
        }// of xpRuleGeneric::xpRuleGeneric
        xpRuleGeneric(const xpRuleGeneric &xr) :
        xboolean(xr.value)
        {   HistoryString = xr.HistoryString;
            Agent = xr.Agent;
            Name = xr.Name;
        }
        virtual
        void    AddStringToHistory(wxString H = "")
        {   if(H.IsEmpty())
                H = wxString::Format(_("(%s is %s)\n"),GetName(),GetValueString(value));
            HistoryString += H;
        }
        virtual
        void    CalculateValue(void)
        {   xpRuleGeneric a = Fire();   // Get the rule, resulting the value
            value = a.value;            // Store the calculated value
            HistoryString = a.GetHistoryString();   // as well as contrib to reasoning
        }
        virtual
        xpRuleGeneric Fire(void)
        {   return  *this;}
        virtual
        wxString    GetHistoryString(void) const
        {   return HistoryString.IsEmpty()
                ? wxString::Format(_("%s is %s"), GetName(), GetValueString(value))
                : HistoryString;
//            return ""; // dummy return string for GNU 
        }
        virtual
        wxString    GetName(void) const
        {   return Name.IsEmpty()
                    ? wxString::Format(_("\"Generic rule\""))  // Name is empty, generic rule
                    : wxString::Format(_("\"%s\""),Name);       
        }
        virtual
        wxString    GetReasoning(void)
        {   CalculateValue();       // Make a fresh copy
            wxString H1 = wxString::Format(_("%s is %s"),GetName(),GetValueString(value));
            wxString H2 = GetHistoryString();
            return HistoryString.IsEmpty()
                ? wxString::Format(_("%s (not an expression)"),H1)
                : wxString::Format(_("%s because\n%s"),H1,H2);  
        }
      static bool GetShortcutMode(void)
      {   return xpShortcutMode;}
        virtual
        wxString    GetValueString(void)
        {   return GetValueString(GetValue());}
        virtual
        wxString    GetValueString(const xbool V) const
        {   if(True == V)
                return _("TRUE");
            else if(False == V)
                return _("FALSE");
            else return _("UNKNOWN");
        }
      static void SetShortcutMode(bool M)
      {   xpShortcutMode = M;}
        xpRuleGeneric& operator = ( xboolean &xb)
        {   xboolean::operator =(xb);
            return *this;
        }
        xpRuleGeneric&  operator = ( const xpRuleGeneric &xb) 
        {   value = xb.value;
            Name = xb.Name;
            HistoryString = xb.HistoryString;
            Agent = xb.Agent;
            return *this;
        }
        xpRuleGeneric operator ! (void)
        {   xboolean *xr =  (xboolean *)this;
            value = (!*xr).GetValue();
            wxString H =  GetHistoryString();
            Name = wxString::Format(_("NOT %s"),Name);
            HistoryString = wxString::Format(_("(NOT (\n%s\n)) is %s\n"), H, GetValueString(value));
            return *this;
        }
        friend xpRuleGeneric
        operator && ( const xpRuleGeneric &xrL, const xpRuleGeneric &xrR)  
        {   xpRuleGeneric res;
            xboolean *xrLv = (xboolean *) &xrL;
            xboolean *xrRv = (xboolean *) &xrR;
            res.value = (*xrLv && *xrRv).GetValue();     // Compute value
            // Now set the history string
            if(xpShortcutMode && ((False == xrL.value)))
                res.HistoryString = xrL.GetHistoryString();
            else if(xpShortcutMode && ((False == xrR.value)))
                res.HistoryString = xrR.GetHistoryString();
            else if(xpShortcutMode && ((Unknown == xrL.value)))
                res.HistoryString = xrL.GetHistoryString();
            else if(xpShortcutMode && ((Unknown == xrR.value)))
                res.HistoryString = xrR.GetHistoryString();
            else 
                res.HistoryString = wxString::Format(_("(%s\n AND \n%s)"),xrL.GetHistoryString(),xrR.GetHistoryString());
            res.Agent = NULL;
            return res; 
        }
        friend xpRuleGeneric
        operator || ( const xpRuleGeneric &xrL, const xpRuleGeneric &xrR)  
        {   xpRuleGeneric res;
            xboolean *xrLv = (xboolean *) &xrL;
            xboolean *xrRv = (xboolean *) &xrR;
            res.value = (*xrLv || *xrRv).GetValue();     // Compute value
            // Now set the history string
            if(xpShortcutMode && (True == xrL.value) )
                res.HistoryString = xrL.GetHistoryString();
            else if(xpShortcutMode && (True == xrR.value))
                res.HistoryString = xrR.GetHistoryString();
            else if(xpShortcutMode && (Unknown == xrL.value))
                res.HistoryString = xrL.GetHistoryString();
            else if(xpShortcutMode && (Unknown == xrR.value))
                res.HistoryString = xrR.GetHistoryString();
            else
                res.HistoryString = wxString::Format(_("(%s\n OR \n%s)"), xrL.GetHistoryString(), xrR.GetHistoryString());
             res.Agent = NULL;
            return res; 
        }
};//xpRuleGeneric

#endif //xprule_h

---