/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/error/error.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/error/error.h Source File#

Composable Kernel: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/error/error.h Source File

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