error.h

// 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_