1

2

3

4

5

6

7

8

9

10

11#ifndef NDARRAY_ArrayTraits_h_INCLUDED

12#define NDARRAY_ArrayTraits_h_INCLUDED

13

23#include <boost/mpl/int.hpp>

24#include <boost/mpl/bool.hpp>

25

26namespace ndarray {

27namespace detail {

28

29template <int N, typename T2, int C2, typename T1, int C1>

31 (((C2>=C1 && C1>=0) || (C2<=C1 && C1<=0) || (N == 1 && C2 == -C1))

32 && boost::is_convertible<T2*,T1*>::value)

33> {};

34

35}

36

37

43template <typename T, int N, int C>

45 typedef T Element;

46 typedef boost::mpl::int_<N> ND;

47 typedef boost::mpl::int_<C> RMC;

50 typedef Array<T,N-1,(N==C)?(N-1):((C>0)?C:0)> Value;

53

54 static Reference makeReference(Element * data, CorePtr const & core) {

56 }

57 static Iterator makeIterator(Element * data, CorePtr const & core, Offset stride) {

59 }

60 static void fill(Iterator iter, Iterator const & end, Element value) {

61

62

63

64

65

66 for (; iter != end; ++iter) {

67 *iter = value;

68 }

69 }

70};

71

72template <typename T>

74 typedef T Element;

75 typedef boost::mpl::int_<1> ND;

76 typedef boost::mpl::int_<0> RMC;

78 typedef Element & Reference;

79 typedef Element Value;

82

83 static Reference makeReference(Element * data, CorePtr const & core) {

84 return *data;

85 }

86 static Iterator makeIterator(Element * data, CorePtr const & core, Offset stride) {

87 return Iterator(data, stride);

88 }

89 static void fill(Iterator iter, Iterator const & end, Element value) {

90 std::fill(iter, end, value);

91 }

92};

93

94template <typename T>

96 typedef T Element;

97 typedef boost::mpl::int_<1> ND;

98 typedef boost::mpl::int_<1> RMC;

99 typedef Element * Iterator;

100 typedef Element & Reference;

101 typedef Element Value;

104

105 static Reference makeReference(Element * data, CorePtr const & core) {

106 return *data;

107 }

108 static Iterator makeIterator(Element * data, CorePtr const & core, Offset stride) {

109 return data;

110 }

111 static void fill(Iterator iter, Iterator const & end, Element value) {

112 std::fill(iter, end, value);

113 }

114};

115

116template <typename T>

118 typedef T Element;

119 typedef boost::mpl::int_<1> ND;

120 typedef boost::mpl::int_<-1> RMC;

121 typedef Element * Iterator;

122 typedef Element & Reference;

123 typedef Element Value;

126

127 static Reference makeReference(Element * data, CorePtr const & core) {

128 return *data;

129 }

130 static Iterator makeIterator(Element * data, CorePtr const & core, Offset stride) {

131 return data;

132 }

133 static void fill(Iterator iter, Iterator const & end, Element value) {

134 std::fill(iter, end, value);

135 }

136};

137

138template <typename T, int N, int C>

141 typedef boost::mpl::false_ IsScalar;

142};

143

144template <typename T, int N, int C>

147 typedef boost::mpl::false_ IsScalar;

148};

149

150}

151

152#endif