Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/pointer_8h_source.html below:

NCBI C++ ToolKit: include/misc/jsonwrapp/rapidjson11/pointer.h Source File

RAPIDJSON_DIAG_OFF(

-

)

RAPIDJSON_DIAG_OFF(4512)

<

ValueType,

Allocator = CrtAllocator>

ValueType::Ch

;

(

Token* tokens,

tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(

) {}

.allocator_ = allocator;

*p =

.CopyFromRaw(*

, 1, token.length + 1);

std::memcpy(p, token.name, (token.length + 1) *

(

));

.tokens_[tokenCount_].name = p;

.tokens_[tokenCount_].length = token.length;

.tokens_[tokenCount_].index = token.index;

Append(token, allocator);

<

T>

Append(name,

(name), allocator);

Append(name.c_str(),

(name.size()), allocator);

(

(Ch) == 1) {

Token token = {

Ch*

(

), length, index };

Append(token, allocator);

(

= 0;

<= length;

++)

name[

] =

Ch

(

[

]);

Token token = { name, length, index };

Append(token, allocator);

GenericPointer Append(

ValueType& token,

* allocator = 0)

{

(token.IsString())

Append(token.GetString(), token.GetStringLength(), allocator);

Append(

(token.GetUint64()), allocator);

GetParseErrorOffset()

{

parseErrorOffset_; }

& GetAllocator() {

*allocator_; }

Token* GetTokens()

{

tokens_; }

GetTokenCount()

{

tokenCount_; }

(

GenericPointer& rhs)

{

(!

() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)

(

= 0;

< tokenCount_;

++) {

(tokens_[

].index != rhs.tokens_[

].index ||

tokens_[

].length != rhs.tokens_[

].length ||

(tokens_[

].length != 0 && std::memcmp(tokens_[

].name, rhs.tokens_[

].name,

(Ch)* tokens_[

].length) != 0))

(

GenericPointer& rhs)

{

!(*

== rhs); }

<

OutputStream>

Stringify(OutputStream& os)

{

Stringify<false, OutputStream>(os);

<

OutputStream>

StringifyUriFragment(OutputStream& os)

{

Stringify<true, OutputStream>(os);

ValueType& Create(ValueType& root,

ValueType::AllocatorType& allocator,

* alreadyExist = 0)

{

ValueType* v = &root;

(

Token *

= tokens_;

!= tokens_ + tokenCount_; ++

) {

(v->IsArray() &&

->name[0] ==

&&

->length == 1) {

v->PushBack(ValueType().SetValueAllocator(&allocator).Move(), allocator);

v = &((*v)[v->Size() - 1]);

(!v->IsArray() && !v->IsObject())

(

->index >= v->Size()) {

v->Reserve(

->index + 1, allocator);

(

->index >= v->Size())

v->PushBack(ValueType().SetValueAllocator(&allocator).Move(), allocator);

v = &((*v)[

->index]);

ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(

->name,

->length));

(m == v->MemberEnd()) {

v->AddMember(ValueType(

->name,

->length, allocator).SetValueAllocator(&allocator).Move(), ValueType().SetValueAllocator(&allocator).Move(), allocator);

*alreadyExist = exist;

<

stackAllocator>

ValueType& Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document,

* alreadyExist = 0)

{

Create(document, document.GetAllocator(), alreadyExist);

ValueType*

(ValueType& root,

* unresolvedTokenIndex = 0)

{

ValueType* v = &root;

(

Token *

= tokens_;

!= tokens_ + tokenCount_; ++

) {

(v->GetType()) {

ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(

->name,

->length));

(m == v->MemberEnd())

v = &((*v)[

->index]);

(unresolvedTokenIndex)

*unresolvedTokenIndex =

(

- tokens_);

ValueType*

(

ValueType& root,

* unresolvedTokenIndex = 0)

{

(

ValueType&

(root), unresolvedTokenIndex);

ValueType& GetWithDefault(ValueType& root,

ValueType&

,

ValueType::AllocatorType& allocator)

{

& v = Create(root, allocator, &alreadyExist);

alreadyExist ? v : v.CopyFrom(

, allocator);

ValueType& GetWithDefault(ValueType& root,

Ch*

,

ValueType::AllocatorType& allocator)

{

& v = Create(root, allocator, &alreadyExist);

alreadyExist ? v : v.SetString(

, allocator);

ValueType& GetWithDefault(ValueType& root,

std::basic_string<Ch>&

,

ValueType::AllocatorType& allocator)

{

& v = Create(root, allocator, &alreadyExist);

alreadyExist ? v : v.SetString(

, allocator);

<

T>

GetWithDefault(ValueType& root,

,

ValueType::AllocatorType& allocator)

{

GetWithDefault(root, ValueType(

).Move(), allocator);

<

stackAllocator>

ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document,

ValueType&

)

{

GetWithDefault(document,

, document.GetAllocator());

<

stackAllocator>

ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document,

Ch*

)

{

GetWithDefault(document,

, document.GetAllocator());

<

stackAllocator>

ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document,

std::basic_string<Ch>&

)

{

GetWithDefault(document,

, document.GetAllocator());

<

T,

stackAllocator>

GetWithDefault(document,

, document.GetAllocator());

ValueType&

(ValueType& root, ValueType&

,

ValueType::AllocatorType& allocator)

{

Create(root, allocator) =

;

ValueType&

(ValueType& root,

ValueType&

,

ValueType::AllocatorType& allocator)

{

Create(root, allocator).CopyFrom(

, allocator);

ValueType&

(ValueType& root,

*

,

ValueType::AllocatorType& allocator)

{

Create(root, allocator) = ValueType(

, allocator).Move();

ValueType& Set(ValueType& root,

std::basic_string<Ch>&

,

ValueType::AllocatorType& allocator)

{

Create(root, allocator) = ValueType(

, allocator).Move();

<

T>

Set(ValueType& root,

, typename ValueType::AllocatorType& allocator)

{

Create(root, allocator) = ValueType(

).Move();

<

stackAllocator>

Create(document) =

;

<

stackAllocator>

<

stackAllocator>

<

stackAllocator>

<

T,

stackAllocator>

Create(document) =

;

ValueType&

(ValueType& root, ValueType&

,

ValueType::AllocatorType& allocator)

{

Create(root, allocator).Swap(

);

<

stackAllocator>

Create(document).Swap(

);

(ValueType& root)

{

(tokenCount_ == 0)

ValueType* v = &root;

Token*

= tokens_ + (tokenCount_ - 1);

(

Token *

= tokens_;

!=

; ++

) {

(v->GetType()) {

(m == v->MemberEnd())

v = &((*v)[

->index]);

(v->GetType()) {

v->Erase(v->Begin() +

->index);

nameBufferSize +=

->length;

tokens_ =

Token *

(allocator_->Malloc(tokenCount_ *

(Token) + (nameBufferSize + extraNameBufferSize) *

(

)));

nameBuffer_ =

*

(tokens_ + tokenCount_);

(nameBufferSize > 0) {

std::memcpy(nameBuffer_, rhs.

, nameBufferSize *

(

));

std::ptrdiff_t diff = nameBuffer_ - rhs.

;

(Token *

= tokens_;

!= tokens_ + rhs.

; ++

)

nameBuffer_ + nameBufferSize;

!((c >=

&& c <=

) || (c >=

&& c <=

) || (c >=

&& c <=

) || c ==

|| c ==

|| c ==

|| c ==

);

Token* token = tokens_ =

Token *

(allocator_->Malloc(tokenCount_ *

(Token) + length *

(

)));

* name = nameBuffer_ =

*

(tokens_ + tokenCount_);

uriFragment =

;

(

!= length &&

[

] !=

) {

(

< length) {

isNumber =

;

(

< length &&

[

] !=

) {

(NeedPercentEncode(c)) {

(c ==

) c =

;

(c ==

) c =

;

(c < '0' || c >

)

token->length =

(name - token->name);

(token->length == 0)

(isNumber && token->length > 1 && token->name[0] ==

)

(

j = 0; j < token->length; j++) {

parseErrorOffset_ =

;

<

uriFragment,

OutputStream>

(Token *

= tokens_;

!= tokens_ + tokenCount_; ++

) {

(

j = 0; j <

->length; j++) {

(c ==

) {

(uriFragment && NeedPercentEncode(c)) {

PercentEncodeStream<OutputStream> target(os);

ValueType::Ch

;

(*src_ !=

|| src_ + 3 > end_) {

(

j = 0; j < 2; j++) {

c =

(c << 4);

(h >=

&& h <=

) c =

(c + h -

);

(h >=

&& h <=

) c =

(c + h -

+ 10);

(h >=

&& h <=

) c =

(c + h -

+ 10);

()

{

(src_ - head_); }

<

OutputStream>

u =

(c);

hexDigits[16] = {

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

};

os_.Put(

typename OutputStream::Ch

(hexDigits[u >> 4]));

os_.Put(

typename OutputStream::Ch

(hexDigits[u & 15]));

<

T>

<

T,

CharType,

N>

<

DocumentType>

.Create(document);

<

DocumentType,

CharType,

N>

<

T>

.Get(root, unresolvedTokenIndex);

<

T>

.Get(root, unresolvedTokenIndex);

<

T,

CharType,

N>

<

T,

CharType,

N>

<

T>

<

T>

<

T>

<

T,

T2>

<

T,

CharType,

N>

<

T,

CharType,

N>

<

T,

CharType,

N>

GenericPointer<typename T::ValueType>(

,

- 1).GetWithDefault(root,

,

);

<

T,

CharType,

N,

T2>

<

DocumentType>

<

DocumentType>

<

DocumentType>

<

DocumentType,

T2>

<

DocumentType,

CharType,

N>

<

DocumentType,

CharType,

N>

<

DocumentType,

CharType,

N>

GenericPointer<typename DocumentType::ValueType>(

,

- 1).GetWithDefault(document,

);

<

DocumentType,

CharType,

N,

T2>

<

T>

<

T>

<

T>

<

T>

T::ValueType&

(

& root,

GenericPointer<typename T::ValueType>&

,

std::basic_string<typename T::Ch>&

,

T::AllocatorType&

) {

<

T,

T2>

((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (

T::ValueType&))

<

T,

CharType,

N>

<

T,

CharType,

N>

<

T,

CharType,

N>

<

T,

CharType,

N>

T::ValueType&

(

& root,

CharType(&

)[

],

std::basic_string<typename T::Ch>&

,

T::AllocatorType&

) {

GenericPointer<typename T::ValueType>(

,

- 1).Set(root,

,

);

<

T,

CharType,

N,

T2>

((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (

T::ValueType&))

GenericPointer<typename T::ValueType>(

,

- 1).Set(root,

,

);

<

DocumentType>

<

DocumentType>

<

DocumentType>

<

DocumentType>

DocumentType::ValueType&

(DocumentType& document,

GenericPointer<typename DocumentType::ValueType>&

,

std::basic_string<typename DocumentType::Ch>&

) {

<

DocumentType,

T2>

((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (

DocumentType::ValueType&))

<

DocumentType,

CharType,

N>

<

DocumentType,

CharType,

N>

<

DocumentType,

CharType,

N>

<

DocumentType,

CharType,

N>

DocumentType::ValueType&

(DocumentType& document,

CharType(&

)[

],

std::basic_string<typename DocumentType::Ch>&

) {

GenericPointer<typename DocumentType::ValueType>(

,

- 1).Set(document,

);

<

DocumentType,

CharType,

N,

T2>

((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (

DocumentType::ValueType&))

GenericPointer<typename DocumentType::ValueType>(

,

- 1).Set(document,

);

<

T>

<

T,

CharType,

N>

<

DocumentType>

<

DocumentType,

CharType,

N>

<

T>

<

T,

CharType,

N>

Concept for allocating, resizing and freeing memory block.

A document for parsing JSON text as DOM.

Allocator & GetAllocator() const

Get the allocator of this document.

A helper stream for decoding a percent-encoded sequence into code unit.

bool valid_

Whether the parsing is valid.

const Ch * src_

Current read position.

PercentDecodeStream(const Ch *source, const Ch *end)

Constructor.

const Ch * head_

Original head of the string.

const Ch * end_

Past-the-end position.

A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence.

PercentEncodeStream(OutputStream &os)

Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.

GenericPointer(const Ch *source, size_t length, Allocator *allocator=0)

Constructor that parses a string or URI fragment representation, with length of the source string.

ValueType & Set(ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const

Set a value in a subtree, with move semantics.

RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(ValueType &)) Set(ValueType &root

Set a primitive value in a subtree.

~GenericPointer()

Destructor.

PointerParseErrorCode parseErrorCode_

Parsing error code.

GenericPointer & operator=(const GenericPointer &rhs)

Assignment operator.

bool Stringify(OutputStream &os) const

Stringify to string or URI fragment representation.

size_t parseErrorOffset_

Offset in code unit when parsing fail.

ValueType & Swap(GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, ValueType &value) const

Swap a value with a value in a document.

Allocator * allocator_

The current allocator. It is either user-supplied or equal to ownAllocator_.

GenericPointer Append(const Ch *name, SizeType length, Allocator *allocator=0) const

Append a name token with length, and return a new Pointer.

bool NeedPercentEncode(Ch c) const

Check whether a character should be percent-encoded.

Ch * CopyFromRaw(const GenericPointer &rhs, size_t extraToken=0, size_t extraNameBufferSize=0)

Clone the content from rhs to this.

Ch * nameBuffer_

A buffer containing all names in tokens.

ValueType::EncodingType EncodingType

Encoding type from Value.

void Parse(const Ch *source, size_t length)

Parse a JSON String or its URI fragment representation into tokens.

ValueType & Swap(ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const

Swap a value with a value in a subtree.

ValueType & Set(ValueType &root, const Ch *value, typename ValueType::AllocatorType &allocator) const

Set a null-terminated string in a subtree.

Allocator stackAllocator RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(ValueType &)) GetWithDefault(GenericDocument< EncodingType

GenericPointer(const Token *tokens, size_t tokenCount)

Constructor with user-supplied tokens.

GenericPointer Append(const Token &token, Allocator *allocator=0) const

Append a token and return a new Pointer.

RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(ValueType &)) Set(GenericDocument< EncodingType

Set a primitive value in a document.

ValueType::Ch Ch

Character type from Value.

Allocator * ownAllocator_

Allocator owned by this Pointer.

GenericPointer(const Ch *source, Allocator *allocator=0)

Constructor that parses a string or URI fragment representation.

bool Erase(ValueType &root) const

Erase a value in a subtree.

ValueType & Set(GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, ValueType &value) const

Set a value in a document, with move semantics.

GenericPointer(const GenericPointer &rhs, Allocator *allocator=0)

Copy constructor.

GenericPointer(Allocator *allocator=0)

Default constructor.

RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr< internal::IsSame< typename internal::RemoveConst< T >::Type, Ch > >),(GenericPointer)) Append(T *name

Append a name token without length, and return a new Pointer.

size_t tokenCount_

Number of tokens in tokens_.

Token * tokens_

A list of tokens.

ValueType & Set(GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, const ValueType &value) const

Set a value in a document, with copy semantics.

ValueType & Set(ValueType &root, const ValueType &value, typename ValueType::AllocatorType &allocator) const

Set a value in a subtree, with copy semantics.

ValueType & Set(GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, const Ch *value) const

Set a null-terminated string in a document.

bool operator==(const CEquivRange &A, const CEquivRange &B)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

bool IsValid(const CSeq_point &pt, CScope *scope)

Checks that point >= 0 and point < length of Bioseq.

#define RAPIDJSON_ASSERT(x)

Assertion.

#define RAPIDJSON_NAMESPACE_BEGIN

provide custom rapidjson namespace (opening expression)

#define RAPIDJSON_NAMESPACE_END

provide custom rapidjson namespace (closing expression)

PointerParseErrorCode

Error code of parsing.

@ kPointerParseErrorInvalidPercentEncoding

Invalid percent encoding in URI fragment.

@ kPointerParseErrorTokenMustBeginWithSolidus

A token must begin with a '/'.

@ kPointerParseErrorInvalidEscape

Invalid escape.

@ kPointerParseErrorNone

The parse is successful.

@ kPointerParseErrorCharacterMustPercentEncode

A character must percent encoded in URI fragment.

bool operator!=(const CNCBI_IPAddr &lhs, unsigned int rhs)

const TYPE & Get(const CNamedParameterList *param)

char * u32toa(uint32_t value, char *buffer)

char * u64toa(uint64_t value, char *buffer)

RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr< internal::IsPointer< T2 >, internal::IsGenericValue< T2 > >),(typename DocumentType::ValueType &)) GetValueByPointerWithDefault(DocumentType &document

const GenericPointer< typename T::ValueType > T2 defaultValue

const GenericPointer< typename T::ValueType > T2 value

const CharType(& source)[N]

unsigned SizeType

Size type (for string lengths, array sizes, etc.)

DocumentType::ValueType & GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], const typename DocumentType::Ch *defaultValue)

DocumentType::ValueType & CreateValueByPointer(DocumentType &document, const CharType(&source)[N])

static const SizeType kPointerInvalidIndex

Represents an invalid index in GenericPointer::Token.

const GenericPointer< typename T::ValueType > & pointer

GenericValue< UTF8<> > Value

GenericValue with UTF8 encoding.

const T::ValueType * GetValueByPointer(const T &root, const CharType(&source)[N], size_t *unresolvedTokenIndex=0)

DocumentType::ValueType & SwapValueByPointer(DocumentType &document, const CharType(&source)[N], typename DocumentType::ValueType &value)

DocumentType::ValueType & SetValueByPointer(DocumentType &document, const CharType(&source)[N], const typename DocumentType::Ch *value)

bool EraseValueByPointer(T &root, const CharType(&source)[N])

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

#define RAPIDJSON_DELETE(x)

! customization point for global delete

#define RAPIDJSON_NEW(TypeName)

! customization point for global new

A read-write string stream.

A token is the basic units of internal representation.

SizeType index

A valid array index, if it is not equal to kPointerInvalidIndex.

const Ch * name

Name of the token. It has null character at the end but it can contain null character.

SizeType length

Length of the name.

Reference to a constant string (not taking a copy)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4