error.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
// 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_