error.h

Go to the documentation of this file.

// Tencent is pleased to support the open source community by making RapidJSON available.
// 
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// 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 RAPIDJSON_ERROR_ERROR_H_
#define RAPIDJSON_ERROR_ERROR_H_
 
#include "../rapidjson.h"
 
#ifdef __clang__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(padded)
#endif
 
// RAPIDJSON_ERROR_CHARTYPE
 
 
#ifndef RAPIDJSON_ERROR_CHARTYPE
#define RAPIDJSON_ERROR_CHARTYPE char
#endif
 
// RAPIDJSON_ERROR_STRING
 
 
#ifndef RAPIDJSON_ERROR_STRING
#define RAPIDJSON_ERROR_STRING(x) x
#endif
 
RAPIDJSON_NAMESPACE_BEGIN
 
// ParseErrorCode
 
 
enum ParseErrorCode {
    kParseErrorNone = 0,                        
 
    kParseErrorDocumentEmpty,                   
    kParseErrorDocumentRootNotSingular,         
 
    kParseErrorValueInvalid,                    
 
    kParseErrorObjectMissName,                  
    kParseErrorObjectMissColon,                 
    kParseErrorObjectMissCommaOrCurlyBracket,   
 
    kParseErrorArrayMissCommaOrSquareBracket,   
 
    kParseErrorStringUnicodeEscapeInvalidHex,   
    kParseErrorStringUnicodeSurrogateInvalid,   
    kParseErrorStringEscapeInvalid,             
    kParseErrorStringMissQuotationMark,         
    kParseErrorStringInvalidEncoding,           
 
    kParseErrorNumberTooBig,                    
    kParseErrorNumberMissFraction,              
    kParseErrorNumberMissExponent,              
 
    kParseErrorTermination,                     
    kParseErrorUnspecificSyntaxError            
};
 
 
struct ParseResult {
    typedef bool (ParseResult::*BooleanType)() const;
public:
    ParseResult() : code_(kParseErrorNone), offset_(0) {}
    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
 
    ParseErrorCode Code() const { return code_; }
    size_t Offset() const { return offset_; }
 
    operator BooleanType() const { return !IsError() ? &ParseResult::IsError : NULL; }
    bool IsError() const { return code_ != kParseErrorNone; }
 
    bool operator==(const ParseResult& that) const { return code_ == that.code_; }
    bool operator==(ParseErrorCode code) const { return code_ == code; }
    friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }
 
    bool operator!=(const ParseResult& that) const { return !(*this == that); }
    bool operator!=(ParseErrorCode code) const { return !(*this == code); }
    friend bool operator!=(ParseErrorCode code, const ParseResult & err) { return err != code; }
 
    void Clear() { Set(kParseErrorNone); }
    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }
 
private:
    ParseErrorCode code_;
    size_t offset_;
};
 
 
typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
 
// ValidateErrorCode
 
 
enum ValidateErrorCode {
    kValidateErrors    = -1,                   
    kValidateErrorNone = 0,                    
 
    kValidateErrorMultipleOf,                  
    kValidateErrorMaximum,                     
    kValidateErrorExclusiveMaximum,            
    kValidateErrorMinimum,                     
    kValidateErrorExclusiveMinimum,            
 
    kValidateErrorMaxLength,                   
    kValidateErrorMinLength,                   
    kValidateErrorPattern,                     
 
    kValidateErrorMaxItems,                    
    kValidateErrorMinItems,                    
    kValidateErrorUniqueItems,                 
    kValidateErrorAdditionalItems,             
 
    kValidateErrorMaxProperties,               
    kValidateErrorMinProperties,               
    kValidateErrorRequired,                    
    kValidateErrorAdditionalProperties,        
    kValidateErrorPatternProperties,           
    kValidateErrorDependencies,                
 
    kValidateErrorEnum,                        
    kValidateErrorType,                        
 
    kValidateErrorOneOf,                       
    kValidateErrorOneOfMatch,                  
    kValidateErrorAllOf,                       
    kValidateErrorAnyOf,                       
    kValidateErrorNot                          
};
 
 
typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetValidateErrorFunc)(ValidateErrorCode);
 
RAPIDJSON_NAMESPACE_END
 
#ifdef __clang__
RAPIDJSON_DIAG_POP
#endif
 
#endif // RAPIDJSON_ERROR_ERROR_H_