Skip to main content

Counted Method Chaining

I built a fun set of classes using C++ template meta-programming technique to count the number of times a member method of a class is invoked in a chain. These template classes implement a meta-programming technique called Counted Method Chaining. It counts the number of times a member function is called at compile-time and does not let programmer invoke it more than a used defiend limit. The limit is passed as a integer template parameter to the class to which to method belongs. It gives a compile time error only when method chaining is used. Otherwise it throws and exception. These set of classes use the C++ technique of co-variant return types.

/// @brief A genereral case of the template where add function
/// is public and therefore, it can be invoked.
template <unsigned int C>
class Base : public Base <C-1>
{
public:
virtual Base <C-1> & add (void const *, size_t length) = 0;
};

/// @brief The special case of the template when C (count) becomes zero.
/// The add member function is private and therefore, can't be
/// invoked by the client of the class resulting in a compile time error.
template <>
class Base <0>
{
public:
virtual ~Base () {}
private:
virtual Base <0> & add (void const *, size_t length) = 0;
};

template <unsigned int SIZE>
class IOV_Helper : public Base <SIZE-1>
{
public:
/// @brief Constructor: Makes a IOV_Helper object.
IOV_Helper () : count_(0) {}

/// @brief Adds a buffer pointer and its size to be sent over network later
/// using gather write technique.
Base <SIZE-1> & add (void const *ptr, size_t length)
{
if (0 == length)
return *this;

if (count_ >= SIZE)
throw count_ + 1;

iov_[count_].iov_base = const_cast <void *> (ptr);
iov_[count_].iov_len = length;
++count_;

return *this;
}

/// @brief Returns the number of I/O vectors populated currently
unsigned int size () { return count_; }

/// @brief Sends the data in the I/O vectors out to a remote peer.
int send (ACE_SOCK_Stream &out)
{
return out.sendv_n (iov_, count_);
}

private:
iovec iov_[SIZE]; /// @brief I/O vectors array.
unsigned int count_; /// @brief count of the number vectors added.
};

int main (void)
{
IOV_Helper <2> sender; /// Here 2 is the maximum limit of method chaining.
char * data = new char[20];
sender.add(data, 20).add(data, 20); /// OK
sender.add(data, 20).add(data, 20).add(data, 20); /// Compile-time Error
return 0;
}

Comments

Sudarshan said…
Long time no posts how are you?
Check out this blog
http://pkisensee.spaces.live.com/

interesting C++ information

Popular posts from this blog

Multi-dimensional arrays in C++11

What new can be said about multi-dimensional arrays in C++? As it turns out, quite a bit! With the advent of C++11, we get new standard library class std::array. We also get new language features, such as template aliases and variadic templates. So I'll talk about interesting ways in which they come together.

It all started with a simple question of how to define a multi-dimensional std::array. It is a great example of deceptively simple things. Are the following the two arrays identical except that one is native and the other one is std::array?

int native[3][4];
std::array<std::array<int, 3>, 4> arr;

No! They are not. In fact, arr is more like an int[4][3]. Note the difference in the array subscripts. The native array is an array of 3 elements where every element is itself an array of 4 integers. 3 rows and 4 columns. If you want a std::array with the same layout, what you really need is:

std::array<std::array<int, 4>, 3> arr;

That's quite annoying for two r…

Understanding Fold Expressions

C++17 has an interesting new feature called fold expressions. Fold expressions offer a compact syntax to apply a binary operation to the elements of a parameter pack. Here’s an example. template <typename... Args> auto addall(Args... args) { return (... + args); } addall(1,2,3,4,5); // returns 15. This particular example is a unary left fold. It's equivalent to ((((1+2)+3)+4)+5). It reduces/folds the parameter pack of integers into a single integer by applying the binary operator successively. It's unary because it does not explicitly specify an init (a.k.a. identity) argument. So, let add it. template <typename... Args> auto addall(Args... args) { return (0 + ... + args); } addall(1,2,3,4,5); // returns 15. This version of addall is a binary left fold. The init argument is 0 and it's redundant (in this case). That's because this fold expression is equivalent to (((((0+1)+2)+3)+4)+5). Explicit identity elements will come in handy a little la…

Folding Monadic Functions

In the previous two blog posts (Understanding Fold Expressions and Folding Functions) we looked at the basic usage of C++17 fold expressions and how simple functions can be folded to create a composite one. We’ll continue our stride and see how "embellished" functions may be composed in fold expressions.

First, let me define what I mean by embellished functions. Instead of just returning a simple value, these functions are going to return a generic container of the desired value. The choice of container is very broad but not arbitrary. There are some constraints on the container and once you select a generic container, all functions must return values of the same container. Let's begin with std::vector.
// Hide the allocator template argument of std::vector. // It causes problems and is irrelevant here. template <class T> struct Vector : std::vector<T> {}; struct Continent { }; struct Country { }; struct State { }; struct City { }; auto get_countries…