Box.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__BOX_HH_
#define __DIADES__UTILS__BOX_HH_

#include <vector>

namespace Diades
{
  namespace Utils
  {
        template<typename Object>
        class Box
        {
        public:
          typedef std::reference_wrapper<Object> Reference;
          
        private:
          std::vector<Reference> _box;


        public:
          Box():_box()
          {
                _box.reserve(1);
          }


          Box(Object & object):_box()
          {
                _box.reserve(1);
                _box.push_back(object);
          }

          

          Box(Box & box):_box()
          {
                _box.reserve(1);
                if(!box.empty())
                  {
                        _box.push_back(box.obj());
                  }
          }



          
          Object & obj() 
          {
                return _box[0];
          }

          const Object & cObj() const
          {
                return _box[0];
          }
          

          bool empty() const
          {
                return _box.empty();
          }
                

          Object & operator=(Object & object)
          {
                _box.clear();
                _box.push_back(object);
                return object;
          }       



          bool operator < (const Box & box) const
          {
                if(empty())
                  {
                        return (!box.empty());
                  }
                if(box.empty())
                  {
                        return false;
                  }
                return cObj() < box.cObj();
          }



          bool operator == (const Box & box) const
          {
                return (empty() && box.empty()) || (cObj() == box.cObj());
          }


          void clear()
          {
                _box.clear();
          }
        };







        template<typename Object>
        class CBox
        {
        public:
          typedef std::reference_wrapper<Object const> Reference;
          
        private:
          std::vector<Reference> _box;


        public:
          CBox():_box()
          {
                _box.reserve(1);
          }


          CBox(const Object & object):_box()
          {
                _box.reserve(1);
                _box.push_back(object);
          }

          

          CBox(const CBox & box):_box()
          {
                _box.reserve(1);
                if(!box.empty())
                  {
                        _box.push_back(box.obj());
                  }
          }



          
          const Object & obj() const 
          {
                return _box[0];
          }


          bool empty() const
          {
                return _box.empty();
          }
                

          const Object & operator=(const Object & object)
          {
                _box.clear();
                _box.push_back(object);
                return object;
          }


          void clear()
          {
                _box.clear();
          }




          bool operator < (const CBox & box) const
          {
                if(empty())
                  {
                        return (!box.empty());
                  }
                if(box.empty())
                  {
                        return false;
                  }
                return obj() < box.obj();
          }



          bool operator == (const CBox & box) const
          {
                return (empty() && box.empty()) || (obj() == box.obj());
          }



          

        };

        
  };
};


namespace std
{
  template<typename Object> struct hash<Diades::Utils::Box<Object> >
  {
        size_t operator()(const Diades::Utils::Box<Object> & box) const
        {
          return hash<Object>()(box.cObj());
        }
  };



  template<typename Object> struct hash<Diades::Utils::CBox<Object> >
  {
        size_t operator()(const Diades::Utils::CBox<Object> & box) const
        {
          return hash<Object>()(box.obj());
        }
  };
};


#endif