Special-case /dev/null in open in the portability header
[folly.git] / folly / FormatArg.h
1 /*
2  * Copyright 2016 Facebook, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #pragma once
18
19 #include <stdexcept>
20 #include <folly/Conv.h>
21 #include <folly/Likely.h>
22 #include <folly/Portability.h>
23 #include <folly/Range.h>
24
25 namespace folly {
26
27 class BadFormatArg : public std::invalid_argument {
28  public:
29   explicit BadFormatArg(const std::string& msg)
30     : std::invalid_argument(msg) {}
31 };
32
33 /**
34  * Parsed format argument.
35  */
36 struct FormatArg {
37   /**
38    * Parse a format argument from a string.  Keeps a reference to the
39    * passed-in string -- does not copy the given characters.
40    */
41   explicit FormatArg(StringPiece sp)
42     : fullArgString(sp),
43       fill(kDefaultFill),
44       align(Align::DEFAULT),
45       sign(Sign::DEFAULT),
46       basePrefix(false),
47       thousandsSeparator(false),
48       trailingDot(false),
49       width(kDefaultWidth),
50       widthIndex(kNoIndex),
51       precision(kDefaultPrecision),
52       presentation(kDefaultPresentation),
53       nextKeyMode_(NextKeyMode::NONE) {
54     if (!sp.empty()) {
55       initSlow();
56     }
57   }
58
59   enum class Type {
60     INTEGER,
61     FLOAT,
62     OTHER
63   };
64   /**
65    * Validate the argument for the given type; throws on error.
66    */
67   void validate(Type type) const;
68
69   /**
70    * Throw an exception if the first argument is false.  The exception
71    * message will contain the argument string as well as any passed-in
72    * arguments to enforce, formatted using folly::to<std::string>.
73    */
74   template <typename... Args>
75   void enforce(bool v, Args&&... args) const {
76     if (UNLIKELY(!v)) {
77       error(std::forward<Args>(args)...);
78     }
79   }
80
81   template <typename... Args>
82   std::string errorStr(Args&&... args) const;
83   template <typename... Args>
84   [[noreturn]] void error(Args&&... args) const;
85
86   /**
87    * Full argument string, as passed in to the constructor.
88    */
89   StringPiece fullArgString;
90
91   /**
92    * Fill
93    */
94   static constexpr char kDefaultFill = '\0';
95   char fill;
96
97   /**
98    * Alignment
99    */
100   enum class Align : uint8_t {
101     DEFAULT,
102     LEFT,
103     RIGHT,
104     PAD_AFTER_SIGN,
105     CENTER,
106     INVALID
107   };
108   Align align;
109
110   /**
111    * Sign
112    */
113   enum class Sign : uint8_t {
114     DEFAULT,
115     PLUS_OR_MINUS,
116     MINUS,
117     SPACE_OR_MINUS,
118     INVALID
119   };
120   Sign sign;
121
122   /**
123    * Output base prefix (0 for octal, 0x for hex)
124    */
125   bool basePrefix;
126
127   /**
128    * Output thousands separator (comma)
129    */
130   bool thousandsSeparator;
131
132   /**
133    * Force a trailing decimal on doubles which could be rendered as ints
134    */
135   bool trailingDot;
136
137   /**
138    * Field width and optional argument index
139    */
140   static constexpr int kDefaultWidth = -1;
141   static constexpr int kDynamicWidth = -2;
142   static constexpr int kNoIndex = -1;
143   int width;
144   int widthIndex;
145
146   /**
147    * Precision
148    */
149   static constexpr int kDefaultPrecision = -1;
150   int precision;
151
152   /**
153    * Presentation
154    */
155   static constexpr char kDefaultPresentation = '\0';
156   char presentation;
157
158   /**
159    * Split a key component from "key", which must be non-empty (an exception
160    * is thrown otherwise).
161    */
162   template <bool emptyOk=false>
163   StringPiece splitKey();
164
165   /**
166    * Is the entire key empty?
167    */
168   bool keyEmpty() const {
169     return nextKeyMode_ == NextKeyMode::NONE && key_.empty();
170   }
171
172   /**
173    * Split an key component from "key", which must be non-empty and a valid
174    * integer (an exception is thrown otherwise).
175    */
176   int splitIntKey();
177
178   void setNextIntKey(int val) {
179     assert(nextKeyMode_ == NextKeyMode::NONE);
180     nextKeyMode_ = NextKeyMode::INT;
181     nextIntKey_ = val;
182   }
183
184   void setNextKey(StringPiece val) {
185     assert(nextKeyMode_ == NextKeyMode::NONE);
186     nextKeyMode_ = NextKeyMode::STRING;
187     nextKey_ = val;
188   }
189
190  private:
191   void initSlow();
192   template <bool emptyOk>
193   StringPiece doSplitKey();
194
195   StringPiece key_;
196   int nextIntKey_;
197   StringPiece nextKey_;
198   enum class NextKeyMode {
199     NONE,
200     INT,
201     STRING,
202   };
203   NextKeyMode nextKeyMode_;
204 };
205
206 template <typename... Args>
207 inline std::string FormatArg::errorStr(Args&&... args) const {
208   return to<std::string>(
209     "invalid format argument {", fullArgString, "}: ",
210     std::forward<Args>(args)...);
211 }
212
213 template <typename... Args>
214 inline void FormatArg::error(Args&&... args) const {
215   throw BadFormatArg(errorStr(std::forward<Args>(args)...));
216 }
217
218 template <bool emptyOk>
219 inline StringPiece FormatArg::splitKey() {
220   enforce(nextKeyMode_ != NextKeyMode::INT, "integer key expected");
221   return doSplitKey<emptyOk>();
222 }
223
224 template <bool emptyOk>
225 inline StringPiece FormatArg::doSplitKey() {
226   if (nextKeyMode_ == NextKeyMode::STRING) {
227     nextKeyMode_ = NextKeyMode::NONE;
228     if (!emptyOk) {  // static
229       enforce(!nextKey_.empty(), "non-empty key required");
230     }
231     return nextKey_;
232   }
233
234   if (key_.empty()) {
235     if (!emptyOk) {  // static
236       error("non-empty key required");
237     }
238     return StringPiece();
239   }
240
241   const char* b = key_.begin();
242   const char* e = key_.end();
243   const char* p;
244   if (e[-1] == ']') {
245     --e;
246     p = static_cast<const char*>(memchr(b, '[', e - b));
247     enforce(p, "unmatched ']'");
248   } else {
249     p = static_cast<const char*>(memchr(b, '.', e - b));
250   }
251   if (p) {
252     key_.assign(p + 1, e);
253   } else {
254     p = e;
255     key_.clear();
256   }
257   if (!emptyOk) {  // static
258     enforce(b != p, "non-empty key required");
259   }
260   return StringPiece(b, p);
261 }
262
263 inline int FormatArg::splitIntKey() {
264   if (nextKeyMode_ == NextKeyMode::INT) {
265     nextKeyMode_ = NextKeyMode::NONE;
266     return nextIntKey_;
267   }
268   try {
269     return to<int>(doSplitKey<true>());
270   } catch (const std::out_of_range& e) {
271     error("integer key required");
272     return 0;  // unreached
273   }
274 }
275
276 }  // namespace folly