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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#ifndef TENSORFLOW_CORE_LIB_CORE_ERRORS_H_
#define TENSORFLOW_CORE_LIB_CORE_ERRORS_H_
#include <sstream>
#include "tensorflow/core/lib/core/status.h"
#include "tensorflow/core/lib/strings/str_util.h"
#include "tensorflow/core/lib/strings/strcat.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/macros.h"
namespace tensorflow {
namespace errors {
typedef ::tensorflow::error::Code Code;
namespace internal {
// The DECLARE_ERROR macro below only supports types that can be converted
// into StrCat's AlphaNum. For the other types we rely on a slower path
// through std::stringstream. To add support of a new type, it is enough to
// make sure there is an operator<<() for it:
//
// std::ostream& operator<<(std::ostream& os, const MyType& foo) {
// os << foo.ToString();
// return os;
// }
// Eventually absl::strings will have native support for this and we will be
// able to completely remove PrepareForStrCat().
template <typename T>
typename std::enable_if<!std::is_constructible<strings::AlphaNum, T>::value,
string>::type
PrepareForStrCat(const T& t) {
std::stringstream ss;
ss << t;
return ss.str();
}
inline const strings::AlphaNum& PrepareForStrCat(const strings::AlphaNum& a) {
return a;
}
} // namespace internal
// Append some context to an error message. Each time we append
// context put it on a new line, since it is possible for there
// to be several layers of additional context.
template <typename... Args>
void AppendToMessage(::tensorflow::Status* status, Args... args) {
*status = ::tensorflow::Status(
status->code(),
::tensorflow::strings::StrCat(status->error_message(), "\n\t", args...));
}
// For propagating errors when calling a function.
#define TF_RETURN_IF_ERROR(...) \
do { \
const ::tensorflow::Status _status = (__VA_ARGS__); \
if (TF_PREDICT_FALSE(!_status.ok())) return _status; \
} while (0)
#define TF_RETURN_WITH_CONTEXT_IF_ERROR(expr, ...) \
do { \
::tensorflow::Status _status = (expr); \
if (TF_PREDICT_FALSE(!_status.ok())) { \
::tensorflow::errors::AppendToMessage(&_status, __VA_ARGS__); \
return _status; \
} \
} while (0)
// Convenience functions for generating and using error status.
// Example usage:
// status.Update(errors::InvalidArgument("The ", foo, " isn't right."));
// if (errors::IsInvalidArgument(status)) { ... }
// switch (status.code()) { case error::INVALID_ARGUMENT: ... }
#define DECLARE_ERROR(FUNC, CONST) \
template <typename... Args> \
::tensorflow::Status FUNC(Args... args) { \
return ::tensorflow::Status( \
::tensorflow::error::CONST, \
::tensorflow::strings::StrCat( \
::tensorflow::errors::internal::PrepareForStrCat(args)...)); \
} \
inline bool Is##FUNC(const ::tensorflow::Status& status) { \
return status.code() == ::tensorflow::error::CONST; \
}
DECLARE_ERROR(Cancelled, CANCELLED)
DECLARE_ERROR(InvalidArgument, INVALID_ARGUMENT)
DECLARE_ERROR(NotFound, NOT_FOUND)
DECLARE_ERROR(AlreadyExists, ALREADY_EXISTS)
DECLARE_ERROR(ResourceExhausted, RESOURCE_EXHAUSTED)
DECLARE_ERROR(Unavailable, UNAVAILABLE)
DECLARE_ERROR(FailedPrecondition, FAILED_PRECONDITION)
DECLARE_ERROR(OutOfRange, OUT_OF_RANGE)
DECLARE_ERROR(Unimplemented, UNIMPLEMENTED)
DECLARE_ERROR(Internal, INTERNAL)
DECLARE_ERROR(Aborted, ABORTED)
DECLARE_ERROR(DeadlineExceeded, DEADLINE_EXCEEDED)
DECLARE_ERROR(DataLoss, DATA_LOSS)
DECLARE_ERROR(Unknown, UNKNOWN)
DECLARE_ERROR(PermissionDenied, PERMISSION_DENIED)
DECLARE_ERROR(Unauthenticated, UNAUTHENTICATED)
#undef DECLARE_ERROR
// Produces a formatted string pattern from the name which can uniquely identify
// this node upstream to produce an informative error message. The pattern
// followed is: {{node <name>}}
// Note: The pattern below determines the regex _NODEDEF_NAME_RE in the file
// tensorflow/python/client/session.py
// LINT.IfChange
inline string FormatNodeNameForError(const string& name) {
return strings::StrCat("{{node ", name, "}}");
}
// LINT.ThenChange(//tensorflow/python/client/session.py)
template <typename T>
string FormatNodeNamesForError(const T& names) {
return ::tensorflow::str_util::Join(
names, ", ", [](string* output, const string& s) {
::tensorflow::strings::StrAppend(output, FormatNodeNameForError(s));
});
}
// LINT.IfChange
inline string FormatColocationNodeForError(const string& name) {
return strings::StrCat("{{colocation_node ", name, "}}");
}
// LINT.ThenChange(//tensorflow/python/framework/error_interpolation.py)
template <typename T>
string FormatColocationNodeForError(const T& names) {
return ::tensorflow::str_util::Join(
names, ", ", [](string* output, const string& s) {
::tensorflow::strings::StrAppend(output,
FormatColocationNodeForError(s));
});
}
// The CanonicalCode() for non-errors.
using ::tensorflow::error::OK;
} // namespace errors
} // namespace tensorflow
#endif // TENSORFLOW_CORE_LIB_CORE_ERRORS_H_
|
