| /* |
| * Copyright 2010 Google Inc. |
| * |
| * 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. |
| */ |
| |
| // Author: jmarantz@google.com (Joshua Marantz) |
| |
| #include "pagespeed/kernel/base/message_handler.h" |
| |
| #include <cstdarg> |
| |
| #include "base/logging.h" |
| |
| namespace net_instaweb { |
| |
| MessageHandler::MessageHandler() : min_message_type_(kInfo) { |
| } |
| |
| MessageHandler::~MessageHandler() { |
| } |
| |
| const char* MessageHandler::MessageTypeToString(const MessageType type) const { |
| const char* type_string = NULL; |
| |
| // Don't include a 'default:' clause so that the compiler can tell us when we |
| // are missing an enum value. Instead use a null check for 'type_string' to |
| // indicate a data corruption that avoids hitting any of the cases. |
| switch (type) { |
| case kInfo: |
| type_string = "Info"; |
| break; |
| case kWarning: |
| type_string = "Warning"; |
| break; |
| case kError: |
| type_string = "Error"; |
| break; |
| case kFatal: |
| type_string = "Fatal"; |
| break; |
| } |
| CHECK(type_string != NULL) << "INVALID MessageType!"; |
| return type_string; |
| } |
| |
| MessageType MessageHandler::StringToMessageType(const StringPiece& msg) { |
| if (StringCaseEqual(msg, "Info")) { |
| return kInfo; |
| } else if (StringCaseEqual(msg, "Warning")) { |
| return kWarning; |
| } else if (StringCaseEqual(msg, "Error")) { |
| return kError; |
| } else if (StringCaseEqual(msg, "Fatal")) { |
| return kFatal; |
| } |
| CHECK(false) << "Invalid msg level: " << msg; |
| return kInfo; |
| } |
| |
| void MessageHandler::Message(MessageType type, const char* msg, ...) { |
| va_list args; |
| va_start(args, msg); |
| MessageV(type, msg, args); |
| va_end(args); |
| } |
| |
| void MessageHandler::MessageV(MessageType type, const char* msg, va_list args) { |
| if (type >= min_message_type_) { |
| MessageVImpl(type, msg, args); |
| } |
| } |
| |
| void MessageHandler::MessageS( |
| MessageType type, const GoogleString& message) { |
| if (type >= min_message_type_) { |
| MessageSImpl(type, message); |
| } |
| } |
| |
| // Default implementation of MessageVImpl formats and then calls MessageS. |
| void MessageHandler::MessageVImpl( |
| MessageType type, const char* msg, va_list args) { |
| GoogleString buffer; |
| FormatTo(&buffer, msg, args); |
| MessageSImpl(type, buffer); |
| } |
| |
| void MessageHandler::FileMessage(MessageType type, const char* file, int line, |
| const char* msg, ...) { |
| va_list args; |
| va_start(args, msg); |
| FileMessageV(type, file, line, msg, args); |
| va_end(args); |
| } |
| |
| void MessageHandler::FileMessageV(MessageType type, const char* filename, |
| int line, const char* msg, va_list args) { |
| if (type >= min_message_type_) { |
| FileMessageVImpl(type, filename, line, msg, args); |
| } |
| } |
| |
| void MessageHandler::FileMessageS(MessageType type, const char* filename, |
| int line, const GoogleString& message) { |
| if (type >= min_message_type_) { |
| FileMessageSImpl(type, filename, line, message); |
| } |
| } |
| |
| void MessageHandler::FileMessageVImpl( |
| MessageType type, const char* filename, int line, |
| const char* msg, va_list args) { |
| GoogleString buffer; |
| FormatTo(&buffer, msg, args); |
| FileMessageSImpl(type, filename, line, buffer); |
| } |
| |
| void MessageHandler::Check(bool condition, const char* msg, ...) { |
| va_list args; |
| va_start(args, msg); |
| CheckV(condition, msg, args); |
| va_end(args); |
| } |
| |
| void MessageHandler::CheckV(bool condition, const char* msg, va_list args) { |
| if (!condition) { |
| MessageV(kFatal, msg, args); |
| } |
| } |
| |
| void MessageHandler::Info(const char* file, int line, const char* msg, ...) { |
| va_list args; |
| va_start(args, msg); |
| InfoV(file, line, msg, args); |
| va_end(args); |
| } |
| |
| void MessageHandler::Warning(const char* file, int line, const char* msg, ...) { |
| va_list args; |
| va_start(args, msg); |
| WarningV(file, line, msg, args); |
| va_end(args); |
| } |
| |
| void MessageHandler::Error(const char* file, int line, const char* msg, ...) { |
| va_list args; |
| va_start(args, msg); |
| ErrorV(file, line, msg, args); |
| va_end(args); |
| } |
| |
| void MessageHandler::FatalError( |
| const char* file, int line, const char* msg, ...) { |
| va_list args; |
| va_start(args, msg); |
| FatalErrorV(file, line, msg, args); |
| va_end(args); |
| } |
| |
| void MessageHandler::FormatTo(GoogleString* buffer, |
| const char* msg, va_list args) { |
| // Ignore the name of this routine: it formats with vsnprintf. |
| // See base/stringprintf.cc. |
| StringAppendV(buffer, msg, args); |
| } |
| |
| bool MessageHandler::Dump(Writer* writer) { |
| return false; |
| } |
| |
| void MessageHandler::ParseMessageDumpIntoMessages( |
| StringPiece message_dump, StringPieceVector* messages) { |
| // Ignore the first line to make sure all the messages dumped are complete. |
| stringpiece_ssize_type pos = message_dump.find("\n"); |
| if (pos != StringPiece::npos) { |
| message_dump.remove_prefix(pos); |
| } |
| SplitStringPieceToVector(message_dump, "\n", messages, false); |
| } |
| |
| MessageType MessageHandler::GetMessageType(StringPiece message) { |
| switch (message[0]) { |
| case 'E': { |
| return kError; |
| } |
| case 'W': { |
| return kWarning; |
| } |
| case 'F': { |
| return kFatal; |
| } |
| default: { |
| return kInfo; |
| } |
| } |
| } |
| |
| StringPiece MessageHandler::ReformatMessage(StringPiece message) { |
| // Remove the first character which is the type indicator. |
| return message.substr(1); |
| } |
| |
| } // namespace net_instaweb |