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
50namespace apache {
51namespace thrift {
52
53class TEnumIterator
54 : public std::iterator<std::forward_iterator_tag, std::pair<int, const char*> > {
55public:
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
69private:
70 int ii_;
71 const int n_;
72 int* enums_;
73 const char** names_;
74};
75
76class TException : public std::exception {
77public:
78 TException() : message_() {}
79
80 TException(const std::string& message) : message_(message) {}
81
82 ~TException() noexcept override = default;
83
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
92protected:
93 std::string message_;
94};
95
96class TDelayedException {
97public:
98 template <class E>
99 static TDelayedException* delayException(const E& e);
100 virtual void throw_it() = 0;
101 virtual ~TDelayedException() = default;
102};
103
104template <class E>
105class TExceptionWrapper : public TDelayedException {
106public:
107 TExceptionWrapper(const E& e) : e_(e) {}
108 void throw_it() override {
109 E temp(e_);
110 delete this;
111 throw temp;
112 }
113
114private:
115 E e_;
116};
117
118template <class E>
119TDelayedException* TDelayedException::delayException(const E& e) {
120 return new TExceptionWrapper<E>(e);
121}
122
123#if T_GLOBAL_DEBUG_VIRTUAL > 1
124void profile_virtual_call(const std::type_info& info);
125void profile_generic_protocol(const std::type_info& template_type, const std::type_info& prot_type);
126void profile_print_info(FILE* f);
127void profile_print_info();
128void 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