error.h Source File

error.h Source File#

Composable Kernel: error.h Source 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,   
 
    kValidateErrorReadOnly, 
    kValidateErrorWriteOnly 
};
typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetValidateErrorFunc)(ValidateErrorCode);
// SchemaErrorCode
enum SchemaErrorCode
{
    kSchemaErrorNone = 0, 
 
    kSchemaErrorStartUnknown, 
    kSchemaErrorRefPlainName, 
    kSchemaErrorRefInvalid,   
    kSchemaErrorRefPointerInvalid,   
    kSchemaErrorRefUnknown,          
    kSchemaErrorRefCyclical,         
    kSchemaErrorRefNoRemoteProvider, 
    kSchemaErrorRefNoRemoteSchema,   
    kSchemaErrorRegexInvalid,    
    kSchemaErrorSpecUnknown,     
    kSchemaErrorSpecUnsupported, 
    kSchemaErrorSpecIllegal,     
    kSchemaErrorReadOnlyAndWriteOnly 
};
typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetSchemaErrorFunc)(SchemaErrorCode);
// PointerParseErrorCode
enum PointerParseErrorCode
{
    kPointerParseErrorNone = 0, 
 
    kPointerParseErrorTokenMustBeginWithSolidus, 
    kPointerParseErrorInvalidEscape,             
    kPointerParseErrorInvalidPercentEncoding,    
    kPointerParseErrorCharacterMustPercentEncode 
};
typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetPointerParseErrorFunc)(PointerParseErrorCode);
 
RAPIDJSON_NAMESPACE_END
 
#ifdef __clang__
RAPIDJSON_DIAG_POP
#endif
 
#endif // RAPIDJSON_ERROR_ERROR_H_