← Back to branch summary

~ubuntu-branches/debian/squeeze/protobuf/squeeze

« back to all changes in this revision

Viewing changes to src/google/protobuf/stubs/hash.h

  • Committer: Bazaar Package Importer
  • Author(s): Julien Cristau
  • Date: 2009-06-02 16:19:00 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090602161900-vm176i3ryt35yk91
Tags: 2.0.3-2.2
* Non-maintainer upload.
* Fix FTBFS from -2.1: don't fail when we can't clean up the java build,
  such as when openjdk isn't installed.
* Disable parallel builds, because libtool is made of fail (if binary-arch
  and build-indep run concurrently, we relink a library while it's being
  used; that doesn't work so well).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/stubs/hash.h
1
1
// Protocol Buffers - Google's data interchange format
2
 
// Copyright 2008 Google Inc.
 
2
// Copyright 2008 Google Inc.  All rights reserved.
3
3
// http://code.google.com/p/protobuf/
4
4
//
5
 
// Licensed under the Apache License, Version 2.0 (the "License");
6
 
// you may not use this file except in compliance with the License.
7
 
// You may obtain a copy of the License at
8
 
//
9
 
//      http://www.apache.org/licenses/LICENSE-2.0
10
 
//
11
 
// Unless required by applicable law or agreed to in writing, software
12
 
// distributed under the License is distributed on an "AS IS" BASIS,
13
 
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 
// See the License for the specific language governing permissions and
15
 
// limitations under the License.
 
5
// Redistribution and use in source and binary forms, with or without
 
6
// modification, are permitted provided that the following conditions are
 
7
// met:
 
8
//
 
9
//     * Redistributions of source code must retain the above copyright
 
10
// notice, this list of conditions and the following disclaimer.
 
11
//     * Redistributions in binary form must reproduce the above
 
12
// copyright notice, this list of conditions and the following disclaimer
 
13
// in the documentation and/or other materials provided with the
 
14
// distribution.
 
15
//     * Neither the name of Google Inc. nor the names of its
 
16
// contributors may be used to endorse or promote products derived from
 
17
// this software without specific prior written permission.
 
18
//
 
19
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
20
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
21
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
22
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
23
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
24
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
25
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
26
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
27
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
28
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
29
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
16
30
 
17
31
// Author: kenton@google.com (Kenton Varda)
18
32
//
29
43
#include HASH_MAP_H
30
44
#include HASH_SET_H
31
45
#else
32
 
// TODO(kenton):  Deal with non-existence of hash_map somehow.  Maybe emulate
33
 
//   it with map?
34
 
#error "Your STL implementation lacks hash_map and/or hash_set."
 
46
#define MISSING_HASH
 
47
#include <map>
 
48
#include <set>
35
49
#endif
36
50
 
37
51
namespace google {
38
52
namespace protobuf {
39
53
 
40
 
#ifdef _MSC_VER
 
54
#ifdef MISSING_HASH
 
55
 
 
56
// This system doesn't have hash_map or hash_set.  Emulate them using map and
 
57
// set.
 
58
 
 
59
// Make hash<T> be the same as less<T>.  Note that everywhere where custom
 
60
// hash functions are defined in the protobuf code, they are also defined such
 
61
// that they can be used as "less" functions, which is required by MSVC anyway.
 
62
template <typename Key>
 
63
struct hash {
 
64
  // Dummy, just to make derivative hash functions compile.
 
65
  int operator()(const Key& key) {
 
66
    GOOGLE_LOG(FATAL) << "Should never be called.";
 
67
    return 0;
 
68
  }
 
69
 
 
70
  inline bool operator()(const Key& a, const Key& b) const {
 
71
    return a < b;
 
72
  }
 
73
};
 
74
 
 
75
// Make sure char* is compared by value.
 
76
template <>
 
77
struct hash<const char*> {
 
78
  // Dummy, just to make derivative hash functions compile.
 
79
  int operator()(const char* key) {
 
80
    GOOGLE_LOG(FATAL) << "Should never be called.";
 
81
    return 0;
 
82
  }
 
83
 
 
84
  inline bool operator()(const char* a, const char* b) const {
 
85
    return strcmp(a, b) < 0;
 
86
  }
 
87
};
 
88
 
 
89
template <typename Key, typename Data,
 
90
          typename HashFcn = hash<Key>,
 
91
          typename EqualKey = int >
 
92
class hash_map : public std::map<Key, Data, HashFcn> {
 
93
};
 
94
 
 
95
template <typename Key,
 
96
          typename HashFcn = hash<Key>,
 
97
          typename EqualKey = int >
 
98
class hash_set : public std::set<Key, HashFcn> {
 
99
};
 
100
 
 
101
#elif defined(_MSC_VER)
41
102
 
42
103
template <typename Key>
43
104
struct hash : public HASH_NAMESPACE::hash_compare<Key> {