placeable_concept.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
#ifndef ADOBE_PLACEABLE_HPP
#define ADOBE_PLACEABLE_HPP
 
/************************************************************************************************/
#include <functional>
 
#include <boost/concept_check.hpp>
 
#include <adobe/extents.hpp>
#include <adobe/layout_attributes.hpp>
 
/************************************************************************************************/
 
namespace adobe {
 
 
/************************************************************************************************/
 
#ifdef ADOBE_HAS_CPLUS0X_CONCEPTS
 
/**************************************************************************************************/
 

auto concept PlaceableConcept<typename T>
    // not yet : RegularConcept<T>
    : std::CopyConstructible<T> {
    void measure(T & t, extents_t & result);
    void place(T & t, const place_data_t& place_data);
};
 
/**************************************************************************************************/

auto concept PlaceableMFConcept<typename Placeable>
    // not yet : RegularConcept<Placeable>
    : std::CopyConstructible<Placeable> {
    void Placeable::measure(extents_t & result);
    void Placeable::place(const place_data_t& place_data);
};
 
/**************************************************************************************************/

template <PlaceableMFConcept T>
concept_map PlaceableConcept<T>{void measure(T & t, extents_t& result){t.measure(result);
}
void place(T& t, const place_data_t& place_data) { t.place(place_data); }
}
;
 
/**************************************************************************************************/

template <PlaceableConcept T>
concept_map PlaceableConcept<std::reference_wrapper<T>>{
    void measure(std::reference_wrapper<T> & r,
                 extents_t& result){PlaceableConcept<T>::measure(static_cast<T&>(r), result);
}
}
;
 
/**************************************************************************************************/

auto concept PlaceableTwoPassConcept<typename Placeable> : PlaceableConcept<Placeable> {
    void measure_vertical(Placeable & p, extents_t & calculated_horizontal,
                          const place_data_t& placed_horizontal);
};
 
/**************************************************************************************************/

auto concept PlaceableTwoPassMFConcept<typename Placeable> : PlaceableMFConcept<Placeable> {
    void Placeable::measure_vertical(extents_t & calculated_horizontal,
                                     const place_data_t& placed_horizontal);
};
 
/**************************************************************************************************/

template <typename T>
concept_map PlaceableTwoPassConcept<PlaceableTwoPassMFConcept<T>>{
    void measure(PlaceableTwoPassMFConcept<T> & t, extents_t& result){t.measure(result);
}
 
void place(PlaceableTwoPassMFConcept<T>& t, const place_data_t& place_data) { t.place(place_data); }
 
void measure_vertical(PlaceableTwoPassMFConcept<T>& t, extents_t& calculated_horizontal,
                      const place_data_t& placed_horizontal) {
    t.measure_vertical(calculated_horizontal, placed_horizontal);
}
}
;
 
/**************************************************************************************************/

template <typename T>
concept_map PlaceableTwoPassConcept<std::reference_wrapper<PlaceableTwoPassConcept<T>>>{
    void measure(std::reference_wrapper<PlaceableTwoPassConcept<T>> & r, extents_t& extents){
        PlaceableTwoPassConcept<PlaceableTwoPassConcept<T>>::measure(*r.get_pointer(), extents);
}
void place(std::reference_wrapper<PlaceableTwoPassConcept<T>>& r,
           const place_data_t& place_data) {
    PlaceableTwoPassConcept<PlaceableTwoPassConcept<T>>::place(*r.get_pointer(), place_data);
}
void measure_vertical(std::reference_wrapper<PlaceableTwoPassConcept<T>>& r,
                      extents_t& calculated_horizontal, const place_data_t& placed_horizontal) {
    PlaceableTwoPassConcept<PlaceableTwoPassConcept<T>>::measure_vertical(
        *r.get_pointer(), calculated_horizontal, placed_horizontal);
}
}
;
 
/**************************************************************************************************/
 
#else
 
/**************************************************************************************************/
 

 
template <class T>
inline void measure(T& t, extents_t& result) {
    t.measure(result);
}
 
/**************************************************************************************************/
 

 
template <class T>
inline void place(T& t, const place_data_t& place_data) {
    t.place(place_data);
}
 
/**************************************************************************************************/

 
template <class T>
struct PlaceableConcept {
#if !defined(ADOBE_NO_DOCUMENTATION)
 
    static void measure(T& t, extents_t& result) {
        using adobe::measure; // pick up default version which looks for member functions
        measure(t, result);   // unqualified to allow user versions
    }
 
    static void place(T& t, const place_data_t& place_data) {
        using adobe::place;   // pick up default version which looks for member functions
        place(t, place_data); // unqualified to allow user versions
    }
 
    // Concept checking:
 
    void constraints() {
        // not yet: boost::function_requires<RegularConcept<Placeable> >();
        // boost::function_requires<boost::CopyConstructibleConcept<Placeable> >();
 
        using adobe::measure;
        measure(*placeable, extents);
 
        using adobe::place;
        place(*placeable, place_data);
    }
 
    // use pointers since not required to be default constructible
    T* placeable;
    const place_data_t place_data;
    extents_t extents;
#endif
};

 
template <class T>
struct PlaceableConcept<T*> : public PlaceableConcept<T> {
    static void measure(T* r, extents_t& result) { PlaceableConcept<T>::measure(*r, result); }
 
    static void place(T* r, const place_data_t& place_data) {
        PlaceableConcept<T>::place(*r, place_data);
    }
 
#if !defined(ADOBE_NO_DOCUMENTATION)
    void constraints() {
        // boost concept check lib gets confused on VC8 without this
        PlaceableConcept<T>::constraints();
    }
#endif
};
 
/**************************************************************************************************/
 

 
template <class T>
inline void measure_vertical(T& t, extents_t& calculated_horizontal,
                             const place_data_t& placed_horizontal) {
    t.measure_vertical(calculated_horizontal, placed_horizontal);
}
 
/**************************************************************************************************/

 
template <class T>
struct PlaceableTwoPassConcept : PlaceableConcept<T> {
#if !defined(ADOBE_NO_DOCUMENTATION)
 
    static void measure_vertical(T& t, extents_t& calculated_horizontal,
                                 const place_data_t& placed_horizontal) {
        using adobe::measure_vertical;
        measure_vertical(t, calculated_horizontal, placed_horizontal);
    }
 
    void constraints() {
        // not yet: boost::function_requires<RegularConcept<T> >();
        // boost::function_requires<boost::CopyConstructibleConcept<T> >();
 
        using adobe::place;
        place(*t2, this->place_data);
 
        using adobe::measure;
        measure(*t2, this->extents);
 
        using adobe::measure_vertical;
        measure_vertical(*t2, this->extents, this->place_data);
    }
 
    // Concept checking:
    // use pointers since not required to be default constructible
    T* t2;
#endif
};

 
template <class T>
struct PlaceableTwoPassConcept<T*> : PlaceableTwoPassConcept<T> {
    static void measure(T* r, extents_t& extents) {
        PlaceableTwoPassConcept<T>::measure(*r, extents);
    }
    static void place(T* r, const place_data_t& place_data) {
        PlaceableTwoPassConcept<T>::place(*r, place_data);
    }
    static void measure_vertical(T* r, extents_t& calculated_horizontal,
                                 const place_data_t& placed_horizontal) {
        PlaceableTwoPassConcept<T>::measure_vertical(*r, calculated_horizontal, placed_horizontal);
    }
 
#if !defined(ADOBE_NO_DOCUMENTATION)
    void constraints() {
        // boost concept check lib gets confused on VC8 without this
        PlaceableTwoPassConcept<T>::constraints();
    }
#endif
};
 
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif