comparable.hpp

Go to the documentation of this file.

// Copyright (C) 2012 iwg molw5
// For conditions of distribution and use, see copyright notice in COPYING

#pragma once

#include <framework/serializable/utility/interface.hpp>

namespace framework
{
    namespace serializable
    {
        namespace detail
        {
            template <typename LhsNames, typename RhsNames>
            struct compare;
        }

        template <typename LhsType, typename RhsType>
        bool less (LhsType const& lhs, RhsType const& rhs)
        {
            return detail::compare <
                    object_names <LhsType>,
                    object_names <RhsType>
                >::less(lhs, rhs);
        }

        template <typename LhsType, typename RhsType>
        bool greater (LhsType const& lhs, RhsType const& rhs)
        {
            return detail::compare <
                    object_names <LhsType>,
                    object_names <RhsType>
                >::greater(lhs, rhs);
        }

        template <typename LhsType, typename RhsType>
        bool less_or_equal (LhsType const& lhs, RhsType const& rhs)
        {
            return detail::compare <
                    object_names <LhsType>,
                    object_names <RhsType>
                >::less_or_equal(lhs, rhs);
        }

        template <typename LhsType, typename RhsType>
        bool greater_or_equal (LhsType const& lhs, RhsType const& rhs)
        {
            return detail::compare <
                    object_names <LhsType>,
                    object_names <RhsType>
                >::greater_or_equal(lhs, rhs);
        }

        template <typename LhsType, typename RhsType>
        bool equal (LhsType const& lhs, RhsType const& rhs)
        {
            return detail::compare <
                    object_names <LhsType>,
                    object_names <RhsType>
                >::equal(lhs, rhs);
        }
        
        template <typename LhsType, typename RhsType>
        bool not_equal (LhsType const& lhs, RhsType const& rhs)
        {
            return detail::compare <
                    object_names <LhsType>,
                    object_names <RhsType>
                >::not_equal(lhs, rhs);
        }

        template <typename Parent>
        struct comparable
        {
            FRAMEWORK_ALWAYS_INLINE
            friend bool operator< (Parent const& lhs, Parent const& rhs)
            {
                return less(lhs, rhs);
            }

            FRAMEWORK_ALWAYS_INLINE
            friend bool operator> (Parent const& lhs, Parent const& rhs)
            {
                return greater(lhs, rhs);
            }

            FRAMEWORK_ALWAYS_INLINE
            friend bool operator<= (Parent const& lhs, Parent const& rhs)
            {
                return less_or_equal(lhs, rhs);
            }

            FRAMEWORK_ALWAYS_INLINE
            friend bool operator>= (Parent const& lhs, Parent const& rhs)
            {
                return greater_or_equal(lhs, rhs);
            }

            FRAMEWORK_ALWAYS_INLINE
            friend bool operator== (Parent const& lhs, Parent const& rhs)
            {
                return equal(lhs, rhs);
            }

            FRAMEWORK_ALWAYS_INLINE
            friend bool operator!= (Parent const& lhs, Parent const& rhs)
            {
                return not_equal(lhs, rhs);
            }
        };
    }
}

#include <framework/serializable/utility/comparable.inl>