// file      : xsde/cxx/hybrid/base.hxx
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file

#ifndef XSDE_CXX_HYBRID_BASE_HXX
#define XSDE_CXX_HYBRID_BASE_HXX

#include <xsde/cxx/config.hxx>

#ifndef XSDE_STL
#  include <string.h> // strcmp
#  include <xsde/cxx/strdupx.hxx>
#endif

#ifdef XSDE_CUSTOM_ALLOCATOR
#  include <xsde/cxx/allocator.hxx>
#endif

namespace xsde
{
  namespace cxx
  {
    namespace hybrid
    {
      // boolean
      //
      struct boolean_base
      {
        bool base_value () const {return x_;}
        bool& base_value () {return x_;}
        void base_value (bool x) {x_ = x;}

        operator const bool& () const {return x_;}
        operator bool& () {return x_;}

        boolean_base& operator= (bool x) {x_ = x; return *this;}

      protected:
        bool x_;
      };

      inline bool
      operator== (const boolean_base& x, const boolean_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const boolean_base& x, const boolean_base& y)
      {
        return !(x == y);
      }

      // byte
      //
      struct byte_base
      {
        signed char base_value () const {return x_;}
        signed char& base_value () {return x_;}
        void base_value (signed char x) {x_ = x;}

        operator const signed char& () const {return x_;}
        operator signed char& () {return x_;}

        byte_base& operator= (signed char x) {x_ = x; return *this;}

      protected:
        signed char x_;
      };

      inline bool
      operator== (const byte_base& x, const byte_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const byte_base& x, const byte_base& y)
      {
        return !(x == y);
      }

      // unsigned_byte
      //
      struct unsigned_byte_base
      {
        unsigned char base_value () const {return x_;}
        unsigned char& base_value () {return x_;}
        void base_value (unsigned char x) {x_ = x;}

        operator const unsigned char& () const {return x_;}
        operator unsigned char& () {return x_;}

        unsigned_byte_base&
        operator= (unsigned char x) {x_ = x; return *this;}

      protected:
        unsigned char x_;
      };

      inline bool
      operator== (const unsigned_byte_base& x, const unsigned_byte_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const unsigned_byte_base& x, const unsigned_byte_base& y)
      {
        return !(x == y);
      }

      // short
      //
      struct short_base
      {
        short base_value () const {return x_;}
        short& base_value () {return x_;}
        void base_value (short x) {x_ = x;}

        operator const short& () const {return x_;}
        operator short& () {return x_;}

        short_base& operator= (short x) {x_ = x; return *this;}

      protected:
        short x_;
      };

      inline bool
      operator== (const short_base& x, const short_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const short_base& x, const short_base& y)
      {
        return !(x == y);
      }

      // unsigned_short
      //
      struct unsigned_short_base
      {
        unsigned short base_value () const {return x_;}
        unsigned short& base_value () {return x_;}
        void base_value (unsigned short x) {x_ = x;}

        operator const unsigned short& () const {return x_;}
        operator unsigned short& () {return x_;}

        unsigned_short_base&
        operator= (unsigned short x) {x_ = x; return *this;}

      protected:
        unsigned short x_;
      };

      inline bool
      operator== (const unsigned_short_base& x, const unsigned_short_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const unsigned_short_base& x, const unsigned_short_base& y)
      {
        return !(x == y);
      }

      // int
      //
      struct int_base
      {
        int base_value () const {return x_;}
        int& base_value () {return x_;}
        void base_value (int x) {x_ = x;}

        operator const int& () const {return x_;}
        operator int& () {return x_;}

        int_base& operator= (int x) {x_ = x; return *this;}

      protected:
        int x_;
      };

      inline bool
      operator== (const int_base& x, const int_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const int_base& x, const int_base& y)
      {
        return !(x == y);
      }

      // unsigned_int
      //
      struct unsigned_int_base
      {
        unsigned int base_value () const {return x_;}
        unsigned int& base_value () {return x_;}
        void base_value (unsigned int x) {x_ = x;}

        operator const unsigned int& () const {return x_;}
        operator unsigned int& () {return x_;}

        unsigned_int_base& operator= (unsigned int x) {x_ = x; return *this;}

      protected:
        unsigned int x_;
      };

      inline bool
      operator== (const unsigned_int_base& x, const unsigned_int_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const unsigned_int_base& x, const unsigned_int_base& y)
      {
        return !(x == y);
      }

      // long
      //
#ifdef XSDE_LONGLONG
      struct long_base
      {
        long long base_value () const {return x_;}
        long long& base_value () {return x_;}
        void base_value (long long x) {x_ = x;}

        operator const long long& () const {return x_;}
        operator long long& () {return x_;}

        long_base& operator= (long long x) {x_ = x; return *this;}

      protected:
        long long x_;
      };
#else
      struct long_base
      {
        long base_value () const {return x_;}
        long& base_value () {return x_;}
        void base_value (long x) {x_ = x;}

        operator const long& () const {return x_;}
        operator long& () {return x_;}

        long_base& operator= (long x) {x_ = x; return *this;}

      protected:
        long x_;
      };
#endif

      inline bool
      operator== (const long_base& x, const long_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const long_base& x, const long_base& y)
      {
        return !(x == y);
      }


      // unsigned_long
      //
#ifdef XSDE_LONGLONG
      struct unsigned_long_base
      {
        unsigned long long base_value () const {return x_;}
        unsigned long long& base_value () {return x_;}
        void base_value (unsigned long long x) {x_ = x;}

        operator const unsigned long long& () const {return x_;}
        operator unsigned long long& () {return x_;}

        unsigned_long_base&
        operator= (unsigned long long x) {x_ = x; return *this;}

      protected:
        unsigned long long x_;
      };
#else
      struct unsigned_long_base
      {
        unsigned long base_value () const {return x_;}
        unsigned long& base_value () {return x_;}
        void base_value (unsigned long x) {x_ = x;}

        operator const unsigned long& () const {return x_;}
        operator unsigned long& () {return x_;}

        unsigned_long_base&
        operator= (unsigned long x) {x_ = x; return *this;}

      protected:
        unsigned long x_;
      };
#endif

      inline bool
      operator== (const unsigned_long_base& x, const unsigned_long_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const unsigned_long_base& x, const unsigned_long_base& y)
      {
        return !(x == y);
      }

      // integer
      //
      struct integer_base
      {
        long base_value () const {return x_;}
        long& base_value () {return x_;}
        void base_value (long x) {x_ = x;}

        operator const long& () const {return x_;}
        operator long& () {return x_;}

        integer_base& operator= (long x) {x_ = x; return *this;}

      protected:
        long x_;
      };

      inline bool
      operator== (const integer_base& x, const integer_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const integer_base& x, const integer_base& y)
      {
        return !(x == y);
      }

      // negative_integer
      //
      struct negative_integer_base
      {
        long base_value () const {return x_;}
        long& base_value () {return x_;}
        void base_value (long x) {x_ = x;}

        operator const long& () const {return x_;}
        operator long& () {return x_;}

        negative_integer_base& operator= (long x) {x_ = x; return *this;}

      protected:
        long x_;
      };

      inline bool
      operator== (const negative_integer_base& x,
                  const negative_integer_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const negative_integer_base& x,
                  const negative_integer_base& y)
      {
        return !(x == y);
      }

      // non_positive_integer
      //
      struct non_positive_integer_base
      {
        long base_value () const {return x_;}
        long& base_value () {return x_;}
        void base_value (long x) {x_ = x;}

        operator const long& () const {return x_;}
        operator long& () {return x_;}

        non_positive_integer_base& operator= (long x) {x_ = x; return *this;}

      protected:
        long x_;
      };

      inline bool
      operator== (const non_positive_integer_base& x,
                  const non_positive_integer_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const non_positive_integer_base& x,
                  const non_positive_integer_base& y)
      {
        return !(x == y);
      }

      // positive_integer
      //
      struct positive_integer_base
      {
        unsigned long base_value () const {return x_;}
        unsigned long& base_value () {return x_;}
        void base_value (unsigned long x) {x_ = x;}

        operator const unsigned long& () const {return x_;}
        operator unsigned long& () {return x_;}

        positive_integer_base&
        operator= (unsigned long x) {x_ = x; return *this;}

      protected:
        unsigned long x_;
      };

      inline bool
      operator== (const positive_integer_base& x,
                  const positive_integer_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const positive_integer_base& x,
                  const positive_integer_base& y)
      {
        return !(x == y);
      }

      // non_negative_integer
      //
      struct non_negative_integer_base
      {
        unsigned long base_value () const {return x_;}
        unsigned long& base_value () {return x_;}
        void base_value (unsigned long x) {x_ = x;}

        operator const unsigned long& () const {return x_;}
        operator unsigned long& () {return x_;}

        non_negative_integer_base&
        operator= (unsigned long x) {x_ = x; return *this;}

      protected:
        unsigned long x_;
      };

      inline bool
      operator== (const non_negative_integer_base& x,
                  const non_negative_integer_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const non_negative_integer_base& x,
                  const non_negative_integer_base& y)
      {
        return !(x == y);
      }

      // float
      //
      struct float_base
      {
        float base_value () const {return x_;}
        float& base_value () {return x_;}
        void base_value (float x) {x_ = x;}

        operator const float& () const {return x_;}
        operator float& () {return x_;}

        float_base& operator= (float x) {x_ = x; return *this;}

      protected:
        float x_;
      };

      inline bool
      operator== (const float_base& x, const float_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const float_base& x, const float_base& y)
      {
        return !(x == y);
      }

      // double
      //
      struct double_base
      {
        double base_value () const {return x_;}
        double& base_value () {return x_;}
        void base_value (double x) {x_ = x;}

        operator const double& () const {return x_;}
        operator double& () {return x_;}

        double_base& operator= (double x) {x_ = x; return *this;}

      protected:
        double x_;
      };

      inline bool
      operator== (const double_base& x, const double_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const double_base& x, const double_base& y)
      {
        return !(x == y);
      }

      // decimal
      //
      struct decimal_base
      {
        double base_value () const {return x_;}
        double& base_value () {return x_;}
        void base_value (double x) {x_ = x;}

        operator const double& () const {return x_;}
        operator double& () {return x_;}

        decimal_base& operator= (double x) {x_ = x; return *this;}

      protected:
        double x_;
      };

      inline bool
      operator== (const decimal_base& x, const decimal_base& y)
      {
        return x.base_value () == y.base_value ();
      }

      inline bool
      operator!= (const decimal_base& x, const decimal_base& y)
      {
        return !(x == y);
      }

#ifndef XSDE_STL
      // string
      //
      struct string_base
      {
        string_base () : x_ (0) {}
        ~string_base ()
        {
#ifndef XSDE_CUSTOM_ALLOCATOR
          delete[] x_;
#else
          cxx::free (x_);
#endif
        }

        const char* base_value () const {return x_;}
        char* base_value () {return x_;}

        void base_value (char* x)
        {
#ifndef XSDE_CUSTOM_ALLOCATOR
          delete[] x_;
#else
          cxx::free (x_);
#endif
          x_ = x;
        }

        char* base_value_detach () {char* r = x_; x_ = 0; return r;}

        operator const char* () const {return x_;}
        operator char* () {return x_;}

        string_base& operator= (char* x) {base_value (x); return *this;}

#ifndef XSDE_EXCEPTIONS
        bool
#else
        void
#endif
        _copy (string_base& c) const
        {
          char* x = strdupx (x_);

#ifndef XSDE_EXCEPTIONS
          if (x == 0)
            return false;
#endif
          c.base_value (x);

#ifndef XSDE_EXCEPTIONS
          return true;
#endif
        }

      protected:
        char* x_;
      };

      inline bool
      operator== (const string_base& x, const string_base& y)
      {
        return strcmp (x.base_value (), y.base_value ()) == 0;
      }

      inline bool
      operator!= (const string_base& x, const string_base& y)
      {
        return !(x == y);
      }
#endif
    }
  }
}

#endif  // XSDE_CXX_HYBRID_BASE_HXX
