include/ndk/support.hh

/* support.hh
 * This file is part of ndk library
 * Copyright (c) 2003,2004 by Stanislav Ievlev
 *
 * This file is covered by the GNU Library General Public License,
 * which should be included with libndk as the file COPYING.
 */
#pragma once

#include <ndk/support.hh>

#include <memory>
#include <stdexcept>
#include <string>

namespace ndk
{
  template<class T>
  class singleton_holder
  {
    /**< simple Meyers' style singleton */
  public:
    typedef T obj_type;
    static T &
    instance ()                      /**< @return instance of the object */
    {
      static T obj;

      return obj;
    }

  private:
    /* all this operations are unavailable to ordinal users */
    singleton_holder ();
    singleton_holder (const singleton_holder &s);
    singleton_holder &operator = (const singleton_holder &s);
    ~singleton_holder ();
  };


  struct NoArg { };

  template<typename RetT, typename ArgT>
  struct functor_impl
  {
    // general polymorphic functor interface
    virtual ~functor_impl ()
    {
    }

    virtual RetT operator () (ArgT) = 0;
  };

  template<typename RetT>
  struct functor_impl<RetT, NoArg>
  {
    // general polymorphic functor interface
    virtual ~functor_impl ()
    {
    }

    virtual RetT operator () () = 0;
  };

  template<typename FunctorT, typename RetT, typename ArgT>
  struct functor_impl_arb
    : public functor_impl<RetT, ArgT>
  {
    // special interface version for arbitrary functor
    functor_impl_arb (const FunctorT &fun)
      : fun_ (fun)
    {
    }

    RetT operator () (ArgT arg)
    {
      return fun_ (arg);
    }

    FunctorT fun_;             // internal copy of the functor
  };

  template<typename FunctorT, typename RetT>
  struct functor_impl_arb<FunctorT, RetT, NoArg>
    : public functor_impl<RetT, NoArg>
  {
    // special interface version for arbitrary functor
    functor_impl_arb (const FunctorT &fun)
      : fun_ (fun)
    {
    }

    RetT operator () ()
    {
      return fun_ ();
    }

    FunctorT fun_;             // internal copy of the functor
  };

  template<typename RetT, typename ArgT = NoArg>
  struct functor
  {
    // generalized functor for ndk callbacks
    typedef functor_impl<RetT, ArgT> impl_type;
    typedef std::shared_ptr<impl_type> invoker_type;

    template<typename FunctorT>
    functor (const FunctorT &fun)
      // initialize with functor type
      : invoker_ (new functor_impl_arb<FunctorT, RetT, ArgT> (fun))
    {
    }

    RetT operator () (ArgT arg)
    {
      // run action
      if (invoker_.get ())
        return (*invoker_.get ()) (arg);
      throw std::runtime_error ("calling empty functor");
    }

    template<typename FunctorT>
    functor<RetT, ArgT> &
    operator = (const FunctorT fun)
    {
      invoker_ = new functor_impl_arb<FunctorT, RetT, ArgT> (fun);
      return *this;
    }

    invoker_type invoker_;
  };

  template<typename RetT>
  struct functor<RetT, NoArg>
  {
    // generalized functor for ndk callbacks
    typedef functor_impl<RetT, NoArg> impl_type;
    typedef std::shared_ptr<impl_type> invoker_type;

    template<typename FunctorT>
    functor (const FunctorT &fun)
      //  initialize with functor type
      : invoker_ (new functor_impl_arb<FunctorT, RetT, NoArg> (fun))
    {
    }

    RetT operator () ()
    {
      // run action
      if (invoker_.get ())
        return (*invoker_.get ())(); throw std::runtime_error ("calling empty functor");
    }

    template<typename FunctorT>
    functor<RetT, NoArg> &
    operator = (const FunctorT fun)
    {
      invoker_ = new functor_impl_arb<FunctorT, RetT, NoArg> (fun);
      return *this;
    }

    invoker_type invoker_;
  };
}
Revision:	1.1
Committed:	Sun Oct 24 20:31:44 2010 UTC (13 years, 9 months ago) by sf-pippijn
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	use EV and plain sockets instead of asio
#	Content
1	/* support.hh
2	* This file is part of ndk library
3	* Copyright (c) 2003,2004 by Stanislav Ievlev
4	*
5	* This file is covered by the GNU Library General Public License,
6	* which should be included with libndk as the file COPYING.
7	*/
8	#pragma once
9
10	#include <ndk/support.hh>
11
12	#include <memory>
13	#include <stdexcept>
14	#include <string>
15
16	namespace ndk
17	{
18	template<class T>
19	class singleton_holder
20	{
21	/*< simple Meyers' style singleton /
22	public:
23	typedef T obj_type;
24	static T &
25	instance () /*< @return instance of the object /
26	{
27	static T obj;
28
29	return obj;
30	}
31
32	private:
33	/* all this operations are unavailable to ordinal users */
34	singleton_holder ();
35	singleton_holder (const singleton_holder &s);
36	singleton_holder &operator = (const singleton_holder &s);
37	~singleton_holder ();
38	};
39
40
41	struct NoArg { };
42
43	template<typename RetT, typename ArgT>
44	struct functor_impl
45	{
46	// general polymorphic functor interface
47	virtual ~functor_impl ()
48	{
49	}
50
51	virtual RetT operator () (ArgT) = 0;
52	};
53
54	template<typename RetT>
55	struct functor_impl<RetT, NoArg>
56	{
57	// general polymorphic functor interface
58	virtual ~functor_impl ()
59	{
60	}
61
62	virtual RetT operator () () = 0;
63	};
64
65	template<typename FunctorT, typename RetT, typename ArgT>
66	struct functor_impl_arb
67	: public functor_impl<RetT, ArgT>
68	{
69	// special interface version for arbitrary functor
70	functor_impl_arb (const FunctorT &fun)
71	: fun_ (fun)
72	{
73	}
74
75	RetT operator () (ArgT arg)
76	{
77	return fun_ (arg);
78	}
79
80	FunctorT fun_; // internal copy of the functor
81	};
82
83	template<typename FunctorT, typename RetT>
84	struct functor_impl_arb<FunctorT, RetT, NoArg>
85	: public functor_impl<RetT, NoArg>
86	{
87	// special interface version for arbitrary functor
88	functor_impl_arb (const FunctorT &fun)
89	: fun_ (fun)
90	{
91	}
92
93	RetT operator () ()
94	{
95	return fun_ ();
96	}
97
98	FunctorT fun_; // internal copy of the functor
99	};
100
101	template<typename RetT, typename ArgT = NoArg>
102	struct functor
103	{
104	// generalized functor for ndk callbacks
105	typedef functor_impl<RetT, ArgT> impl_type;
106	typedef std::shared_ptr<impl_type> invoker_type;
107
108	template<typename FunctorT>
109	functor (const FunctorT &fun)
110	// initialize with functor type
111	: invoker_ (new functor_impl_arb<FunctorT, RetT, ArgT> (fun))
112	{
113	}
114
115	RetT operator () (ArgT arg)
116	{
117	// run action
118	if (invoker_.get ())
119	return (*invoker_.get ()) (arg);
120	throw std::runtime_error ("calling empty functor");
121	}
122
123	template<typename FunctorT>
124	functor<RetT, ArgT> &
125	operator = (const FunctorT fun)
126	{
127	invoker_ = new functor_impl_arb<FunctorT, RetT, ArgT> (fun);
128	return *this;
129	}
130
131	invoker_type invoker_;
132	};
133
134	template<typename RetT>
135	struct functor<RetT, NoArg>
136	{
137	// generalized functor for ndk callbacks
138	typedef functor_impl<RetT, NoArg> impl_type;
139	typedef std::shared_ptr<impl_type> invoker_type;
140
141	template<typename FunctorT>
142	functor (const FunctorT &fun)
143	// initialize with functor type
144	: invoker_ (new functor_impl_arb<FunctorT, RetT, NoArg> (fun))
145	{
146	}
147
148	RetT operator () ()
149	{
150	// run action
151	if (invoker_.get ())
152	return (*invoker_.get ())(); throw std::runtime_error ("calling empty functor");
153	}
154
155	template<typename FunctorT>
156	functor<RetT, NoArg> &
157	operator = (const FunctorT fun)
158	{
159	invoker_ = new functor_impl_arb<FunctorT, RetT, NoArg> (fun);
160	return *this;
161	}
162
163	invoker_type invoker_;
164	};
165	}