Multboolean for c++/python

MultiBoolean.h

////////////////////////////////////////////////////////////////////////////////
//MultiBoolean C++ 实现
//基于C#源码库MarchLibrary中的MultiBoolean
//作者：刘鑫
//本代码库旨在演示Boost::Python的运算符重载技术，并提供一个实用的C++/Python
//类。
////////////////////////////////////////////////////////////////////////////////

#ifndef __MULTIBOOLEAN__
#define __MULTIBOOLEAN__

#include <string>
#include <complex>
#include <algorithm>
#include <stdexcept>

using namespace std;

namespace MarchLibrary{

class MultiBoolean
{
//友元定义
friend MultiBoolean operator ! (const MultiBoolean & x);
friend MultiBoolean operator == (const MultiBoolean & x, const MultiBoolean & y);
friend MultiBoolean operator == (const MultiBoolean & x, const bool & y);
friend MultiBoolean operator == (const bool & x, const MultiBoolean & y);
friend MultiBoolean operator != (const MultiBoolean & x, const MultiBoolean & y);
friend MultiBoolean operator != (const MultiBoolean & x, const bool & y);
friend MultiBoolean operator != (const bool & x, const MultiBoolean & y);
friend MultiBoolean operator && (const MultiBoolean & x, const MultiBoolean & y);
friend MultiBoolean operator && (const MultiBoolean & x, const bool & y);
friend MultiBoolean operator && (const bool & x, const MultiBoolean & y);
friend MultiBoolean operator || (const MultiBoolean & x, const MultiBoolean & y);
friend MultiBoolean operator || (const MultiBoolean & x, const bool & y);
friend MultiBoolean operator || (const bool & x, const MultiBoolean & y);

private:
        //逻辑状态
        complex<int> _value;
        //禁用默认构造
        MultiBoolean(){};
        //禁止直接调用传值构造
        MultiBoolean(complex<int> value)
        {
                _value = value;
        }

        //可选的5个状态值 
        static const complex<int> TrueValue;
        static const complex<int> FalseValue;
        static const complex<int> UnknownValue;
        static const complex<int> UndefineValue;
        static const complex<int> NilValue;

public:

        //重载逻辑运算符 &= 、 |= 和 ^=
        MultiBoolean& operator &= (const MultiBoolean& x)
        {
                if(this->_value == MultiBoolean::NilValue)
                        return (*this);

                else if(x._value == MultiBoolean::NilValue)
                        this->_value = NilValue;

                else if(this->_value == MultiBoolean::UndefineValue)
                        this->_value = x._value;

                else if(this->_value.real() > x._value.real())
                        this->_value = x._value;

                return (*this);
        }

        MultiBoolean& operator &= (const bool& x)
        {
                if(this->_value == MultiBoolean::NilValue)
                        return (*this);

                else if(this->_value == MultiBoolean::UndefineValue)
                        this->_value = x ? TrueValue : FalseValue;

                else if(!x)
                        this->_value = FalseValue;

                return (*this);
        }

        MultiBoolean& operator |= (const MultiBoolean& x)
        {
                if(this->_value == MultiBoolean::NilValue)
                        return (*this);

                else if(x._value == MultiBoolean::NilValue)
                        this->_value = NilValue;

                else if(this->_value == MultiBoolean::UndefineValue)
                        this->_value = x._value;

                else if(this->_value.real() < x._value.real())
                        this->_value = x._value;

                return (*this);
        }

        MultiBoolean& operator |= (const bool& x)
        {
                if(this->_value == MultiBoolean::NilValue)
                        return (*this);

                else if(this->_value == MultiBoolean::UndefineValue)
                        this->_value = x ? TrueValue : FalseValue;

                else if(x)
                        this->_value = TrueValue;

                return (*this);
        }

        MultiBoolean & operator ^= (const MultiBoolean & x)
        {
                this->_value = ((!x&&this)||(x&&!this))._value;
                return (*this);
        }

        MultiBoolean & operator ^= (const bool & x)
        {
                this->_value = MultiBoolean((!x&&this)||(x&&!this))._value;
                return (*this);
        }

        //由二元逻辑构造多值逻辑
        MultiBoolean(bool value)
        {
                _value = value ? complex<int>(1, 0) : complex<int>(-1, 0);
        };

        //状态判定函数
        bool IsTrue()
        {
                return _value == TrueValue;
        };

        bool IsFalse()
        {
                return _value == FalseValue;
        };

        bool IsUnknown()
        {
                return _value == UnknownValue;
        };

        bool IsUndefine()
        {
                return _value == UndefineValue;
        };

        bool IsNil()
        {
                return _value == NilValue;
        };

        //字符串与多值逻辑的相互转换
        const char* ToString()
        {
                if(_value == TrueValue)
                        return "True";
                if(_value == FalseValue)
                        return "False";
                if(_value == UndefineValue)
                        return "Undefine";
                if(_value == NilValue)
                        return "Nil";

                return "Unknown";
        };

        string FullName()
        {
                string buf = string("MultiBoolean::");
                buf += this->ToString();
                return buf;
        }

        static MultiBoolean Parse(const char * input)
        {
                if("True" == input)
                        return True;

                if("False" == input)
                        return False;

                if("Unknown" == input)
                        return Unknown;

        if("Undefine" == input)
                        return Undefine;

                if("Nil" == input)
                        return Nil;

                throw logic_error(string("The string isn't a available Value.") + string(input));
        };

        //可选的逻辑值，提供构造接口
        static const MultiBoolean True;
        static const MultiBoolean False;
        static const MultiBoolean Unknown;
        static const MultiBoolean Undefine;
        static const MultiBoolean Nil;
};

//初始化状态值
const complex<int> MultiBoolean::TrueValue              =       complex<int>(1, 0);
const complex<int> MultiBoolean::FalseValue             =       complex<int>(-1, 0);
const complex<int> MultiBoolean::UnknownValue   =       complex<int>(0, 0);
const complex<int> MultiBoolean::UndefineValue  =       complex<int>(0, 1);
const complex<int> MultiBoolean::NilValue               =       complex<int>(0, -1);

//初始化逻辑值
const MultiBoolean MultiBoolean::True           =       MultiBoolean(TrueValue);
const MultiBoolean MultiBoolean::False  =       MultiBoolean(FalseValue);
const MultiBoolean MultiBoolean::Unknown        =       MultiBoolean(UnknownValue);
const MultiBoolean MultiBoolean::Undefine       =       MultiBoolean(UndefineValue);
const MultiBoolean MultiBoolean::Nil    =       MultiBoolean(NilValue);

//为C++版提供便捷的逻辑状态定义
const MultiBoolean True         =       MultiBoolean::True;
const MultiBoolean False        =       MultiBoolean::False;
const MultiBoolean Unknown      =       MultiBoolean::Unknown;
const MultiBoolean Undefine     =       MultiBoolean::Undefine;
const MultiBoolean Nil          =       MultiBoolean::Nil;


//非运算
MultiBoolean operator !(const MultiBoolean & x)
{
        return MultiBoolean(-(x._value));
};


//相等比较

MultiBoolean operator == (const MultiBoolean & x, const MultiBoolean & y)
{
        if(x._value.real() == 0 && y._value.real() == 0)
                return MultiBoolean(complex<int>(0, min(x._value.imag(), y._value.imag())));

        if(x._value.real() == 0 && y._value.real() != 0)
                return MultiBoolean(x._value);

        if(x._value.real() != 0 && y._value.real() == 0)
                return MultiBoolean(y._value);

        return MultiBoolean(x._value.real() == y._value.real() ? True : False);
};

MultiBoolean operator==(const MultiBoolean & x, const bool & y)
{
        if(x._value.real() == 0)
                return x;

        return MultiBoolean((x._value.real() == 1) == y);
};

MultiBoolean operator==(const bool & x, const MultiBoolean & y)
{
    if(y._value.real() == 0)
                return y;

        return MultiBoolean(x == (y._value.real() == 1));
};

//不等比较

MultiBoolean operator!=(const MultiBoolean & x, const MultiBoolean & y)
{
        if(x._value.real() == 0 && y._value.real() == 0)
                return MultiBoolean(complex<int>(0, min(x._value.imag(), y._value.imag())));

        if(x._value.real() == 0 && y._value.real() != 0)
                return MultiBoolean(x._value);

        if(x._value.real() != 0 && y._value.real() == 0)
                return MultiBoolean(y._value);

        return MultiBoolean(x._value.real() == y._value.real() ? False : True);
};

MultiBoolean operator!=(const MultiBoolean & x, const bool & y)
{
        if(x._value.real() == 0)
                return x;

        return MultiBoolean((x._value.real() == -1) == y);
};

MultiBoolean operator!=(const bool & x, const MultiBoolean & y)
{
    if(y._value.real() == 0)
                return y;

        return MultiBoolean(x == (y._value.real() == -1));
};

//与运算

MultiBoolean operator && (const MultiBoolean & x, const MultiBoolean & y)
{
        if((x._value == MultiBoolean::NilValue) || (y._value == MultiBoolean::NilValue))
                return Nil;

        if(x._value == MultiBoolean::UndefineValue)
                return y;
        if(y._value == MultiBoolean::UndefineValue)
                return x;

        return MultiBoolean(x._value.real() < y._value.real() ? x._value : y._value);
};

MultiBoolean operator && (const MultiBoolean & x, const bool & y)
{
        return x && MultiBoolean(y);
}

MultiBoolean operator && (const bool & x, const MultiBoolean & y)
{
        return MultiBoolean(x) && y;
};

//或运算

MultiBoolean operator || (const MultiBoolean & x, const MultiBoolean & y)
{
        if(x._value == MultiBoolean::NilValue || y._value == MultiBoolean::NilValue)
                return Nil;

        if(x._value == MultiBoolean::UndefineValue)
                return MultiBoolean(y._value);
        if(y._value == MultiBoolean::UndefineValue)
                return MultiBoolean(x._value);

        return MultiBoolean(x._value.real() > y._value.real() ? x._value : y._value);
};

MultiBoolean operator || (const bool & x, const MultiBoolean & y)
{
        return MultiBoolean(x) || y;
};

MultiBoolean operator || (const MultiBoolean & x, const bool & y)
{
        return x || MultiBoolean(y);
};

//异或运算

MultiBoolean operator ^ (const MultiBoolean & x, const MultiBoolean & y)
{
        return (!x&&y)||(x&&!y);
};

MultiBoolean operator ^ (const bool & x, const MultiBoolean & y)
{
        return (!x&&y)||(x&&!y);
};

MultiBoolean operator ^ (const MultiBoolean & x, const bool & y)
{
        return (!x&&y)||(x&&!y);
};

}

#endif 

pyMultiBoolean.h

////////////////////////////////////////////////////////////
//与/或运算的Python接口封装
//作者：刘鑫
//Python中的与/或运算由&和|表达，为了不与C++中的按位与/或
//定义冲突，将这两个运算符定义放到单独的头文件中，仅供Python
//封装定义。
////////////////////////////////////////////////////////////

#ifndef __PYMULTIBOOLEAN__
#define __PYMULTIBOOLEAN__

#include "MultiBoolean.h"

namespace MarchLibrary{

//与运算

MultiBoolean operator & (MultiBoolean x, MultiBoolean y)
{
        return x && y;
};

MultiBoolean operator & (MultiBoolean x, bool y)
{
        return x && y;
}

MultiBoolean operator & (bool x, MultiBoolean y)
{
        return x && y;
};

//或运算

MultiBoolean operator | (MultiBoolean x, MultiBoolean y)
{
        return x || y;
};

MultiBoolean operator | (bool x, MultiBoolean y)
{
        return x || y;
};

MultiBoolean operator | (MultiBoolean x, bool y)
{
        return x || y;
};

}

#endif 

wrapper.cpp

///////////////////////////////////////////////////////////
//MultiBoolean类的Python封装，使用boost::python技术
//作者：刘鑫
///////////////////////////////////////////////////////////

//引用boost库
#include <boost/python.hpp>
//引用多值逻辑定义
#include "MultiBoolean.h"
//引用与或运算的Python封装接口
#include "pyMultiBoolean.h"

//引用相关的命名空间

using namespace boost::python;

using namespace MarchLibrary;

//模块定义
BOOST_PYTHON_MODULE(MarchLibrary)
{
        //类封装，这里用no_init表示没有可用的构造函数
        class_<MultiBoolean>("MultiBoolean", no_init)
                //可选的逻辑值接口
                .def_readonly("True", &MultiBoolean::True)
                .def_readonly("False", &MultiBoolean::False)
                .def_readonly("Unknown", &MultiBoolean::Unknown)
                .def_readonly("Undefine", &MultiBoolean::Undefine)
                .def_readonly("Nil", &MultiBoolean::Nil)

                //兼容C++版定义的字符串处理接口
                .def("ToString", &MultiBoolean::ToString)
                .def("FullName", &MultiBoolean::FullName)
                .def("Parse", &MultiBoolean::Parse)

                //逻辑值判定
                .def("IsTrue", &MultiBoolean::IsTrue)
                .def("IsFalse", &MultiBoolean::IsFalse)
                .def("IsUnknown", &MultiBoolean::IsUnknown)
                .def("IsUndefine", &MultiBoolean::IsUndefine)
                .def("IsNil", &MultiBoolean::IsNil)

                //运算符重载接口
                .def(!self)
                .def(self &= self)
                .def(self &= bool())
                .def(self |= self)
                .def(self |= bool())
                .def(self ^= self)
                .def(self ^= bool())
                .def(self == self)
                .def(self == bool())
                .def(bool() == self)
                .def(self != self)
                .def(self != bool())
                .def(bool() != self)
                .def(self & self)
                .def(self & bool())
                .def(bool() & self)
                .def(self | self)
                .def(self | bool())
                .def(bool() | self)
                .def(self ^ self)
                .def(self ^ bool())
                .def(bool() ^ self)

                //提供给Python解释器的标准字符串输出接口
                .def("__str__", &MultiBoolean::ToString)
                .def("__repr__", &MultiBoolean::FullName)
        ;
}