|
|
| ChannelGeometry (size_t images=1, size_t alphas=0) |
| |
|
| ChannelGeometry (const ChannelGeometry &g) |
| |
|
template<size_t N> |
| | ChannelGeometry (drain::UniTuple< size_t, N > &tuple, size_t i) |
| |
|
ChannelGeometry & | operator= (const ChannelGeometry &g) |
| |
|
void | setChannelCount (const ChannelGeometry &g) |
| |
|
void | setChannelCount (size_t imageChannelCount, size_t alphaChannelCount=0) |
| |
|
void | setAlphaChannelCount (size_t a) |
| |
|
size_t | getChannelCount () const |
| | Return the number of channels (image and alpha)
|
| |
|
size_t | getImageChannelCount () const |
| | Return the number of actual image channels (excluding alphas)
|
| |
|
size_t | getAlphaChannelCount () const |
| | Return the number of alpha channels.
|
| |
|
| UniTuple (const TT &... args) |
| |
|
| UniTuple (const UniTuple< size_t, N > &t) |
| | Copy constructor.
|
| |
|
| UniTuple (std::initializer_list< S > l) |
| |
|
tuple_t & | operator= (const tuple_t &t) |
| |
|
tuple_t & | operator= (const value_type &value) |
| |
|
tuple_t & | operator= (std::initializer_list< S > l) |
| |
| virtual const_iterator | begin () const override final |
| |
| virtual iterator | begin () override final |
| |
| virtual const_iterator | end () const override final |
| |
| virtual iterator | end () override final |
| |
|
const tuple_t & | tuple () const |
| |
|
tuple_t & | tuple () |
| |
|
tuple_t & | tuple (const TT &... args) |
| |
|
void | debug (std::ostream &ostr) const |
| |
| const S & | at (size_t i) const |
| | Return const reference to element i.
|
| |
|
const S & | operator[] (size_t i) const |
| |
| S & | at (size_t i) |
| | Return reference to element i.
|
| |
|
S & | operator[] (size_t i) |
| |
|
bool | operator== (const tuplebase_t &t) const |
| | Equality operator.
|
| |
| bool | operator== (const value_type &t) const |
| | Equality operator against single value.
|
| |
|
bool | operator!= (const tuplebase_t &t) const |
| | Inequality operator.
|
| |
|
template<class T > |
| T & | toSequence (T &sequence) const |
| | Copy elements to a Sequence, like stl::list, stl::set or stl::vector.
|
| |
|
void | set (const tuplebase_t &t) |
| |
|
template<class T2 , size_t N2 = 2> |
| void | set (const TupleBase< T2, N2 > &t) |
| | Assign tuple of different type and/or size.
|
| |
|
void | set (const S &arg) |
| |
|
template<typename ... SS> |
| void | set (const S &arg, const SS &... rest) |
| | Set element(s).
|
| |
|
template<typename T > |
| void | set (std::initializer_list< T > l) |
| |
| template<class T > |
| tuplebase_t & | assignSequence (T &sequence, bool LENIENT=false) |
| | Proposed for tuples only; derived classes should not shadow this.
|
| |
|
void | fill (S i) |
| | Set all the elements to i.
|
| |
|
void | clear () |
| |
| virtual void | toStreamFormatted (std::ostream &ostr, char separator=',') const |
| |
|
virtual void | toStream (std::ostream &ostr) const |
| |
|
std::string | toStr (char separator=',') const |
| |
|
virtual void | updateTuple () |
| |
|
|
typedef size_t | value_type |
| |
|
typedef UniTuple< size_t, N > | tuple_t |
| |
|
typedef size_t * | iterator |
| |
|
typedef const size_t * | const_iterator |
| |
|
typedef TupleBase< S, N > | tuplebase_t |
| |
|
typedef S | value_type |
| |
|
typedef S * | iterator |
| |
|
typedef S const * | const_iterator |
| |
| static size_t | size () |
| | Return the number of elements.
|
| |
|
static const size_t | tuple_size |
| |
|
static const size_t | storageTypeSize = sizeof(S) |
| |
|
| UniTuple (UniTuple< size_t, N2 > &tuple, size_t i) |
| |
|
size_t & | next () |
| |
|
void | setIndexed (size_t i) |
| | Argument stack endpoint function; final step of variadic argument set(arg, ...) .
|
| |
|
template<typename T2 , typename ... TT> |
| void | setIndexed (size_t i, T2 arg, const TT &... rest) |
| | Worker called by set(T2 arg, T2 arg2, ...)
|
| |
Public Member Functions inherited from UniTuple< size_t, 2 >
1.9.8