Instigate Open Source Documentation

---

src/algebra/_additive_group.hpp

Go to the documentation of this file.

#ifndef _INSTIGATE_OPEN_SOURCE_INTERNAL_HEADER_IN_CONCEPT
#error This is an internal header file used to implement Instigate Algebra.\
        It should never be included directly by a program.
#endif

#ifndef INSTIGATE_ALGEBRA_ADDITIVE_GROUP_HPP
#define INSTIGATE_ALGEBRA_ADDITIVE_GROUP_HPP

// Headers from this project
#include "_additive_monoid.hpp"

// Headers from other projects
#include <generic/base.hpp>

// Headers from standard libraries

// Forward declarations
namespace instigate {
        
        namespace algebra {
                
                namespace additive_group {
                        struct tag;
                        template <typename T> struct interface;
                        template <typename T> struct requirements;
                        
                } // namespace instigate::algebra::additive_group
                
        } // namespace instigate::algebra
        
} // namespace instigate

struct instigate::algebra::additive_group::tag : 
        instigate::algebra::additive_monoid::tag {};

template <typename T>
struct instigate::algebra::additive_group::interface : 
        instigate::algebra::additive_monoid::interface<T>
{
        static T opposite(const T& a)
        {
                return instigate::algebra::interface<T>::opposite(a);
        }

        static T minus(const T& a, const T& b)
        {
                return instigate::algebra::interface<T>::minus(a, b);
        }
};

template <typename T>
struct instigate::algebra::additive_group::requirements : 
        instigate::algebra::additive_monoid::requirements<T>
{
        static void require_opposite(const T& a)
        {
                instigate::algebra::additive_group::interface<T>::opposite(a);
        }
        
        static void require_opposite_return_type(const T& a)
        {
                REQUIRE_SAME_TYPE(a, interface<T>::opposite(a));
        }

        static void require_minus(const T& a, const T& b)
        {
                instigate::algebra::additive_group::interface<T>::minus(a, b);
        }
        
        static void require_minus_return_type(const T& a, const T& b)
        {
                REQUIRE_SAME_TYPE(a, interface<T>::minus(a, b));
        }

        requirements()
        {
                (void)&require_opposite;
                (void)&require_opposite_return_type;
                (void)&require_minus;
                (void)&require_minus_return_type;
        }
};

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_ALGEBRA_ADDITIVE_GROUP_HPP

---

© Instigate CJSC, Open Source