1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19
20 #ifndef _THRIFT_THRIFT_H_
21 #define _THRIFT_THRIFT_H_ 1
22
23 #include <thrift/transport/PlatformSocket.h>
24
25 #include <thrift/thrift-config.h>
26
27 #include <stdio.h>
28 #include <assert.h>
29
30 #include <sys/types.h>
31 #ifdef HAVE_NETINET_IN_H
32 #include <netinet/in.h>
33 #endif
34 #ifdef HAVE_INTTYPES_H
35 #include <inttypes.h>
36 #endif
37 #include <string>
38 #include <map>
39 #include <list>
40 #include <set>
41 #include <vector>
42 #include <exception>
43 #include <typeinfo>
44
45 #include <thrift/TLogging.h>
46 #include <thrift/TOutput.h>
47
48 #define THRIFT_UNUSED_VARIABLE(x) ((void)(x))
49
50 namespace apache {
51 namespace thrift {
52
53 class TEnumIterator
54 : public std::iterator<std::forward_iterator_tag, std::pair<int, const char*> > {
55 public:
TEnumIterator(int n,int * enums,const char ** names)56 TEnumIterator(int n, int* enums, const char** names)
57 : ii_(0), n_(n), enums_(enums), names_(names) {}
58
59 int operator++() { return ++ii_; }
60
61 bool operator!=(const TEnumIterator& end) {
62 THRIFT_UNUSED_VARIABLE(end);
63 assert(end.n_ == -1);
64 return (ii_ != n_);
65 }
66
67 std::pair<int, const char*> operator*() const { return std::make_pair(enums_[ii_], names_[ii_]); }
68
69 private:
70 int ii_;
71 const int n_;
72 int* enums_;
73 const char** names_;
74 };
75
76 class TException : public std::exception {
77 public:
TException()78 TException() : message_() {}
79
TException(const std::string & message)80 TException(const std::string& message) : message_(message) {}
81
82 virtual ~TException() noexcept override = default;
83
what()84 const char* what() const noexcept override {
85 if (message_.empty()) {
86 return "Default TException.";
87 } else {
88 return message_.c_str();
89 }
90 }
91
92 protected:
93 std::string message_;
94 };
95
96 class TDelayedException {
97 public:
98 template <class E>
99 static TDelayedException* delayException(const E& e);
100 virtual void throw_it() = 0;
101 virtual ~TDelayedException() = default;
102 };
103
104 template <class E>
105 class TExceptionWrapper : public TDelayedException {
106 public:
TExceptionWrapper(const E & e)107 TExceptionWrapper(const E& e) : e_(e) {}
throw_it()108 void throw_it() override {
109 E temp(e_);
110 delete this;
111 throw temp;
112 }
113
114 private:
115 E e_;
116 };
117
118 template <class E>
delayException(const E & e)119 TDelayedException* TDelayedException::delayException(const E& e) {
120 return new TExceptionWrapper<E>(e);
121 }
122
123 #if T_GLOBAL_DEBUG_VIRTUAL > 1
124 void profile_virtual_call(const std::type_info& info);
125 void profile_generic_protocol(const std::type_info& template_type, const std::type_info& prot_type);
126 void profile_print_info(FILE* f);
127 void profile_print_info();
128 void profile_write_pprof(FILE* gen_calls_f, FILE* virtual_calls_f);
129 #endif
130 }
131 } // apache::thrift
132
133 #endif // #ifndef _THRIFT_THRIFT_H_
134