Drizzled Public API Documentation

string.h
1 /* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3  *
4  * Copyright (C) 2010 Brian Aker
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  * * Redistributions of source code must retain the above copyright notice,
11  * this list of conditions and the following disclaimer.
12  * * Redistributions in binary form must reproduce the above copyright notice,
13  * this list of conditions and the following disclaimer in the documentation
14  * and/or other materials provided with the distribution.
15  * * Neither the name of Patrick Galbraith nor the names of its contributors
16  * may be used to endorse or promote products derived from this software
17  * without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
29  * THE POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 /*
33  Some sections of this code came from the Boost examples.
34 */
35 
36 #pragma once
37 
38 #include <utility>
39 #include <string>
40 #include <vector>
41 
42 #include <boost/algorithm/string/predicate.hpp>
43 #include <boost/foreach.hpp>
44 #include <boost/functional/hash.hpp>
45 #include <boost/shared_ptr.hpp>
46 
47 #define drizzle_literal_parameter(X) (X), size_t((sizeof(X) - 1))
48 
49 namespace drizzled {
50 namespace util {
51 
52 struct insensitive_equal_to : std::binary_function<std::string, std::string, bool>
53 {
54  bool operator()(std::string const& x, std::string const& y) const
55  {
56  return boost::algorithm::iequals(x, y);
57  }
58 };
59 
60 struct insensitive_hash : std::unary_function<std::string, std::size_t>
61 {
62  std::size_t operator()(std::string const& x) const
63  {
64  std::size_t seed = 0;
65  BOOST_FOREACH(std::string::const_reference it, x)
66  boost::hash_combine(seed, std::toupper(it));
67  return seed;
68  }
69 };
70 
71 struct sensitive_hash : std::unary_function< std::vector<char>, std::size_t>
72 {
73  std::size_t operator()(std::vector<char> const& x) const
74  {
75  std::size_t seed = 0;
76  BOOST_FOREACH(std::vector<char>::const_reference it, x)
77  boost::hash_combine(seed, it);
78  return seed;
79  }
80 };
81 
82 class String
83 {
84 public:
85 
86  String()
87  {
88  _bytes.resize(1);
89  }
90 
91  const char* data() const
92  {
93  return &_bytes[0];
94  }
95 
96  char* data()
97  {
98  return &_bytes[0];
99  }
100 
101  void assign(const size_t repeat, const char arg)
102  {
103  _bytes.resize(repeat + 1); // inserts \0 at end
104  memset(&_bytes[0], arg, repeat);
105  _bytes[repeat]= 0;
106  }
107 
108  void assign(const char *arg, const size_t arg_size)
109  {
110  _bytes.resize(arg_size + 1); // +1 for \0
111  memcpy(&_bytes[0], arg, arg_size);
112  _bytes[arg_size]= 0;
113  }
114 
115  void append(const char *arg, const size_t arg_size)
116  {
117  if (not arg or not arg_size)
118  return;
119 
120  size_t original_size= size();
121  if (original_size)
122  {
123  _bytes.resize(original_size + arg_size + 1); // inserts NULL since string will already have a NULL
124  memcpy(&_bytes[original_size], arg, arg_size);
125  _bytes[original_size + arg_size]= 0;
126  }
127  else
128  {
129  assign(arg, arg_size);
130  }
131  }
132 
133  const char& operator[] (size_t arg) const
134  {
135  return _bytes[arg];
136  }
137 
138  char& operator[] (size_t arg)
139  {
140  return _bytes[arg];
141  }
142 
143  void clear()
144  {
145  _bytes.resize(1);
146  _bytes[0]= 0;
147  }
148 
149  size_t size() const
150  {
151  return _bytes.size() -1;
152  }
153 
154 private:
155  std::vector<char> _bytes;
156 };
157 
158 } /* namespace util */
159 } /* namespace drizzled */
160 
TODO: Rename this file - func.h is stupid.