summaryrefslogtreecommitdiff
path: root/libfrontend-elements/frontend-elements/context.hxx
blob: 9a31da27d354aa5782c07c70411d41a298898a24 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
// file      : frontend-elements/context.hxx
// author    : Boris Kolpackov <boris@kolpackov.net>
// copyright : Copyright (c) 2005-2010 Boris Kolpackov
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file

#ifndef FRONTEND_ELEMENTS_CONTEXT_HXX
#define FRONTEND_ELEMENTS_CONTEXT_HXX

#include <frontend-elements/types.hxx>

#include <cult/containers/any.hxx>
#include <cult/containers/map.hxx>

namespace FrontendElements
{
  class Context: public NonCopyable
  {
    typedef
    Cult::Containers::Map<String, Cult::Containers::Any>
    Map;

  public:
    struct NoEntry {};
    struct Typing {};

    Context ()
    {
    }

    Void
    swap (Context& c)
    {
      map_.swap (c.map_);
    }

    Size
    count (Char const* key) const
    {
      return map_.count (key);
    }

    template <typename X>
    X&
    get (Char const* key)
    {
      Map::Iterator i (map_.find (key));

      if (i == map_.end ())
        throw NoEntry ();

      try
      {
        return i->second. template value<X> ();
      }
      catch (Cult::Containers::Any::Typing const&)
      {
        throw Typing ();
      }
    }

    template <typename X>
    X const&
    get (Char const* key) const
    {
      Map::ConstIterator i (map_.find (key));

      if (i == map_.end ())
        throw NoEntry ();

      try
      {
        return i->second. template value<X> ();
      }
      catch (Cult::Containers::Any::Typing const&)
      {
        throw Typing ();
      }
    }

    template <typename X>
    X const&
    get (Char const* key, X const& default_value) const
    {
      Map::ConstIterator i (map_.find (key));

      if (i == map_.end ())
        return default_value;

      try
      {
        return i->second. template value<X> ();
      }
      catch (Cult::Containers::Any::Typing const&)
      {
        throw Typing ();
      }
    }

    template <typename X>
    Void
    set (Char const* key, X const& value)
    {
      try
      {
        if (!map_.insert (Map::Pair (key, value)).second)
        {
          Map::Iterator i (map_.find (key));
          i->second.template value <X> () = value;
        }
      }
      catch (Cult::Containers::Any::Typing const&)
      {
        throw Typing ();
      }
    }

    Void
    remove (Char const* key)
    {
      Map::Iterator i (map_.find (key));

      if (i == map_.end ())
        throw NoEntry ();

      map_.erase (i);
    }

  private:
    Map map_;
  };
}

#endif  // FRONTEND_ELEMENTS_CONTEXT_HXX