Code style: Rename BinaryXML to BinaryXml
diff --git a/ndn-cpp/c/encoding/BinaryXML.h b/ndn-cpp/c/encoding/BinaryXML.h
index 587b2fc..eb5d2b4 100644
--- a/ndn-cpp/c/encoding/BinaryXML.h
+++ b/ndn-cpp/c/encoding/BinaryXML.h
@@ -11,130 +11,130 @@
#endif
enum {
- ndn_BinaryXML_EXT = 0x00,
- ndn_BinaryXML_TAG = 0x01,
- ndn_BinaryXML_DTAG = 0x02,
- ndn_BinaryXML_ATTR = 0x03,
- ndn_BinaryXML_DATTR = 0x04,
- ndn_BinaryXML_BLOB = 0x05,
- ndn_BinaryXML_UDATA = 0x06,
- ndn_BinaryXML_CLOSE = 0x0,
+ ndn_BinaryXml_EXT = 0x00,
+ ndn_BinaryXml_TAG = 0x01,
+ ndn_BinaryXml_DTAG = 0x02,
+ ndn_BinaryXml_ATTR = 0x03,
+ ndn_BinaryXml_DATTR = 0x04,
+ ndn_BinaryXml_BLOB = 0x05,
+ ndn_BinaryXml_UDATA = 0x06,
+ ndn_BinaryXml_CLOSE = 0x0,
- ndn_BinaryXML_TT_BITS = 3,
- ndn_BinaryXML_TT_MASK = ((1 << ndn_BinaryXML_TT_BITS) - 1),
- ndn_BinaryXML_TT_VALUE_BITS = 4,
- ndn_BinaryXML_TT_VALUE_MASK = ((1 << (ndn_BinaryXML_TT_VALUE_BITS)) - 1),
- ndn_BinaryXML_REGULAR_VALUE_BITS = 7,
- ndn_BinaryXML_REGULAR_VALUE_MASK = ((1 << ndn_BinaryXML_REGULAR_VALUE_BITS) - 1),
- ndn_BinaryXML_TT_FINAL = 0x80,
+ ndn_BinaryXml_TT_BITS = 3,
+ ndn_BinaryXml_TT_MASK = ((1 << ndn_BinaryXml_TT_BITS) - 1),
+ ndn_BinaryXml_TT_VALUE_BITS = 4,
+ ndn_BinaryXml_TT_VALUE_MASK = ((1 << (ndn_BinaryXml_TT_VALUE_BITS)) - 1),
+ ndn_BinaryXml_REGULAR_VALUE_BITS = 7,
+ ndn_BinaryXml_REGULAR_VALUE_MASK = ((1 << ndn_BinaryXml_REGULAR_VALUE_BITS) - 1),
+ ndn_BinaryXml_TT_FINAL = 0x80,
- ndn_BinaryXML_DTag_Any = 13,
- ndn_BinaryXML_DTag_Name = 14,
- ndn_BinaryXML_DTag_Component = 15,
- ndn_BinaryXML_DTag_Certificate = 16,
- ndn_BinaryXML_DTag_Collection = 17,
- ndn_BinaryXML_DTag_CompleteName = 18,
- ndn_BinaryXML_DTag_Content = 19,
- ndn_BinaryXML_DTag_SignedInfo = 20,
- ndn_BinaryXML_DTag_ContentDigest = 21,
- ndn_BinaryXML_DTag_ContentHash = 22,
- ndn_BinaryXML_DTag_Count = 24,
- ndn_BinaryXML_DTag_Header = 25,
- ndn_BinaryXML_DTag_Interest = 26, /* 20090915 */
- ndn_BinaryXML_DTag_Key = 27,
- ndn_BinaryXML_DTag_KeyLocator = 28,
- ndn_BinaryXML_DTag_KeyName = 29,
- ndn_BinaryXML_DTag_Length = 30,
- ndn_BinaryXML_DTag_Link = 31,
- ndn_BinaryXML_DTag_LinkAuthenticator = 32,
- ndn_BinaryXML_DTag_NameComponentCount = 33, /* DeprecatedInInterest */
- ndn_BinaryXML_DTag_RootDigest = 36,
- ndn_BinaryXML_DTag_Signature = 37,
- ndn_BinaryXML_DTag_Start = 38,
- ndn_BinaryXML_DTag_Timestamp = 39,
- ndn_BinaryXML_DTag_Type = 40,
- ndn_BinaryXML_DTag_Nonce = 41,
- ndn_BinaryXML_DTag_Scope = 42,
- ndn_BinaryXML_DTag_Exclude = 43,
- ndn_BinaryXML_DTag_Bloom = 44,
- ndn_BinaryXML_DTag_BloomSeed = 45,
- ndn_BinaryXML_DTag_AnswerOriginKind = 47,
- ndn_BinaryXML_DTag_InterestLifetime = 48,
- ndn_BinaryXML_DTag_Witness = 53,
- ndn_BinaryXML_DTag_SignatureBits = 54,
- ndn_BinaryXML_DTag_DigestAlgorithm = 55,
- ndn_BinaryXML_DTag_BlockSize = 56,
- ndn_BinaryXML_DTag_FreshnessSeconds = 58,
- ndn_BinaryXML_DTag_FinalBlockID = 59,
- ndn_BinaryXML_DTag_PublisherPublicKeyDigest = 60,
- ndn_BinaryXML_DTag_PublisherCertificateDigest = 61,
- ndn_BinaryXML_DTag_PublisherIssuerKeyDigest = 62,
- ndn_BinaryXML_DTag_PublisherIssuerCertificateDigest = 63,
- ndn_BinaryXML_DTag_ContentObject = 64, /* 20090915 */
- ndn_BinaryXML_DTag_WrappedKey = 65,
- ndn_BinaryXML_DTag_WrappingKeyIdentifier = 66,
- ndn_BinaryXML_DTag_WrapAlgorithm = 67,
- ndn_BinaryXML_DTag_KeyAlgorithm = 68,
- ndn_BinaryXML_DTag_Label = 69,
- ndn_BinaryXML_DTag_EncryptedKey = 70,
- ndn_BinaryXML_DTag_EncryptedNonceKey = 71,
- ndn_BinaryXML_DTag_WrappingKeyName = 72,
- ndn_BinaryXML_DTag_Action = 73,
- ndn_BinaryXML_DTag_FaceID = 74,
- ndn_BinaryXML_DTag_IPProto = 75,
- ndn_BinaryXML_DTag_Host = 76,
- ndn_BinaryXML_DTag_Port = 77,
- ndn_BinaryXML_DTag_MulticastInterface = 78,
- ndn_BinaryXML_DTag_ForwardingFlags = 79,
- ndn_BinaryXML_DTag_FaceInstance = 80,
- ndn_BinaryXML_DTag_ForwardingEntry = 81,
- ndn_BinaryXML_DTag_MulticastTTL = 82,
- ndn_BinaryXML_DTag_MinSuffixComponents = 83,
- ndn_BinaryXML_DTag_MaxSuffixComponents = 84,
- ndn_BinaryXML_DTag_ChildSelector = 85,
- ndn_BinaryXML_DTag_RepositoryInfo = 86,
- ndn_BinaryXML_DTag_Version = 87,
- ndn_BinaryXML_DTag_RepositoryVersion = 88,
- ndn_BinaryXML_DTag_GlobalPrefix = 89,
- ndn_BinaryXML_DTag_LocalName = 90,
- ndn_BinaryXML_DTag_Policy = 91,
- ndn_BinaryXML_DTag_Namespace = 92,
- ndn_BinaryXML_DTag_GlobalPrefixName = 93,
- ndn_BinaryXML_DTag_PolicyVersion = 94,
- ndn_BinaryXML_DTag_KeyValueSet = 95,
- ndn_BinaryXML_DTag_KeyValuePair = 96,
- ndn_BinaryXML_DTag_IntegerValue = 97,
- ndn_BinaryXML_DTag_DecimalValue = 98,
- ndn_BinaryXML_DTag_StringValue = 99,
- ndn_BinaryXML_DTag_BinaryValue = 100,
- ndn_BinaryXML_DTag_NameValue = 101,
- ndn_BinaryXML_DTag_Entry = 102,
- ndn_BinaryXML_DTag_ACL = 103,
- ndn_BinaryXML_DTag_ParameterizedName = 104,
- ndn_BinaryXML_DTag_Prefix = 105,
- ndn_BinaryXML_DTag_Suffix = 106,
- ndn_BinaryXML_DTag_Root = 107,
- ndn_BinaryXML_DTag_ProfileName = 108,
- ndn_BinaryXML_DTag_Parameters = 109,
- ndn_BinaryXML_DTag_InfoString = 110,
- ndn_BinaryXML_DTag_StatusResponse = 112,
- ndn_BinaryXML_DTag_StatusCode = 113,
- ndn_BinaryXML_DTag_StatusText = 114,
- ndn_BinaryXML_DTag_SyncNode = 115,
- ndn_BinaryXML_DTag_SyncNodeKind = 116,
- ndn_BinaryXML_DTag_SyncNodeElement = 117,
- ndn_BinaryXML_DTag_SyncVersion = 118,
- ndn_BinaryXML_DTag_SyncNodeElements = 119,
- ndn_BinaryXML_DTag_SyncContentHash = 120,
- ndn_BinaryXML_DTag_SyncLeafCount = 121,
- ndn_BinaryXML_DTag_SyncTreeDepth = 122,
- ndn_BinaryXML_DTag_SyncByteCount = 123,
- ndn_BinaryXML_DTag_SyncConfigSlice = 124,
- ndn_BinaryXML_DTag_SyncConfigSliceList = 125,
- ndn_BinaryXML_DTag_SyncConfigSliceOp = 126,
- ndn_BinaryXML_DTag_SyncNodeDeltas = 127,
- ndn_BinaryXML_DTag_SequenceNumber = 256,
- ndn_BinaryXML_DTag_CCNProtocolDataUnit = 17702112
+ ndn_BinaryXml_DTag_Any = 13,
+ ndn_BinaryXml_DTag_Name = 14,
+ ndn_BinaryXml_DTag_Component = 15,
+ ndn_BinaryXml_DTag_Certificate = 16,
+ ndn_BinaryXml_DTag_Collection = 17,
+ ndn_BinaryXml_DTag_CompleteName = 18,
+ ndn_BinaryXml_DTag_Content = 19,
+ ndn_BinaryXml_DTag_SignedInfo = 20,
+ ndn_BinaryXml_DTag_ContentDigest = 21,
+ ndn_BinaryXml_DTag_ContentHash = 22,
+ ndn_BinaryXml_DTag_Count = 24,
+ ndn_BinaryXml_DTag_Header = 25,
+ ndn_BinaryXml_DTag_Interest = 26, /* 20090915 */
+ ndn_BinaryXml_DTag_Key = 27,
+ ndn_BinaryXml_DTag_KeyLocator = 28,
+ ndn_BinaryXml_DTag_KeyName = 29,
+ ndn_BinaryXml_DTag_Length = 30,
+ ndn_BinaryXml_DTag_Link = 31,
+ ndn_BinaryXml_DTag_LinkAuthenticator = 32,
+ ndn_BinaryXml_DTag_NameComponentCount = 33, /* DeprecatedInInterest */
+ ndn_BinaryXml_DTag_RootDigest = 36,
+ ndn_BinaryXml_DTag_Signature = 37,
+ ndn_BinaryXml_DTag_Start = 38,
+ ndn_BinaryXml_DTag_Timestamp = 39,
+ ndn_BinaryXml_DTag_Type = 40,
+ ndn_BinaryXml_DTag_Nonce = 41,
+ ndn_BinaryXml_DTag_Scope = 42,
+ ndn_BinaryXml_DTag_Exclude = 43,
+ ndn_BinaryXml_DTag_Bloom = 44,
+ ndn_BinaryXml_DTag_BloomSeed = 45,
+ ndn_BinaryXml_DTag_AnswerOriginKind = 47,
+ ndn_BinaryXml_DTag_InterestLifetime = 48,
+ ndn_BinaryXml_DTag_Witness = 53,
+ ndn_BinaryXml_DTag_SignatureBits = 54,
+ ndn_BinaryXml_DTag_DigestAlgorithm = 55,
+ ndn_BinaryXml_DTag_BlockSize = 56,
+ ndn_BinaryXml_DTag_FreshnessSeconds = 58,
+ ndn_BinaryXml_DTag_FinalBlockID = 59,
+ ndn_BinaryXml_DTag_PublisherPublicKeyDigest = 60,
+ ndn_BinaryXml_DTag_PublisherCertificateDigest = 61,
+ ndn_BinaryXml_DTag_PublisherIssuerKeyDigest = 62,
+ ndn_BinaryXml_DTag_PublisherIssuerCertificateDigest = 63,
+ ndn_BinaryXml_DTag_ContentObject = 64, /* 20090915 */
+ ndn_BinaryXml_DTag_WrappedKey = 65,
+ ndn_BinaryXml_DTag_WrappingKeyIdentifier = 66,
+ ndn_BinaryXml_DTag_WrapAlgorithm = 67,
+ ndn_BinaryXml_DTag_KeyAlgorithm = 68,
+ ndn_BinaryXml_DTag_Label = 69,
+ ndn_BinaryXml_DTag_EncryptedKey = 70,
+ ndn_BinaryXml_DTag_EncryptedNonceKey = 71,
+ ndn_BinaryXml_DTag_WrappingKeyName = 72,
+ ndn_BinaryXml_DTag_Action = 73,
+ ndn_BinaryXml_DTag_FaceID = 74,
+ ndn_BinaryXml_DTag_IPProto = 75,
+ ndn_BinaryXml_DTag_Host = 76,
+ ndn_BinaryXml_DTag_Port = 77,
+ ndn_BinaryXml_DTag_MulticastInterface = 78,
+ ndn_BinaryXml_DTag_ForwardingFlags = 79,
+ ndn_BinaryXml_DTag_FaceInstance = 80,
+ ndn_BinaryXml_DTag_ForwardingEntry = 81,
+ ndn_BinaryXml_DTag_MulticastTTL = 82,
+ ndn_BinaryXml_DTag_MinSuffixComponents = 83,
+ ndn_BinaryXml_DTag_MaxSuffixComponents = 84,
+ ndn_BinaryXml_DTag_ChildSelector = 85,
+ ndn_BinaryXml_DTag_RepositoryInfo = 86,
+ ndn_BinaryXml_DTag_Version = 87,
+ ndn_BinaryXml_DTag_RepositoryVersion = 88,
+ ndn_BinaryXml_DTag_GlobalPrefix = 89,
+ ndn_BinaryXml_DTag_LocalName = 90,
+ ndn_BinaryXml_DTag_Policy = 91,
+ ndn_BinaryXml_DTag_Namespace = 92,
+ ndn_BinaryXml_DTag_GlobalPrefixName = 93,
+ ndn_BinaryXml_DTag_PolicyVersion = 94,
+ ndn_BinaryXml_DTag_KeyValueSet = 95,
+ ndn_BinaryXml_DTag_KeyValuePair = 96,
+ ndn_BinaryXml_DTag_IntegerValue = 97,
+ ndn_BinaryXml_DTag_DecimalValue = 98,
+ ndn_BinaryXml_DTag_StringValue = 99,
+ ndn_BinaryXml_DTag_BinaryValue = 100,
+ ndn_BinaryXml_DTag_NameValue = 101,
+ ndn_BinaryXml_DTag_Entry = 102,
+ ndn_BinaryXml_DTag_ACL = 103,
+ ndn_BinaryXml_DTag_ParameterizedName = 104,
+ ndn_BinaryXml_DTag_Prefix = 105,
+ ndn_BinaryXml_DTag_Suffix = 106,
+ ndn_BinaryXml_DTag_Root = 107,
+ ndn_BinaryXml_DTag_ProfileName = 108,
+ ndn_BinaryXml_DTag_Parameters = 109,
+ ndn_BinaryXml_DTag_InfoString = 110,
+ ndn_BinaryXml_DTag_StatusResponse = 112,
+ ndn_BinaryXml_DTag_StatusCode = 113,
+ ndn_BinaryXml_DTag_StatusText = 114,
+ ndn_BinaryXml_DTag_SyncNode = 115,
+ ndn_BinaryXml_DTag_SyncNodeKind = 116,
+ ndn_BinaryXml_DTag_SyncNodeElement = 117,
+ ndn_BinaryXml_DTag_SyncVersion = 118,
+ ndn_BinaryXml_DTag_SyncNodeElements = 119,
+ ndn_BinaryXml_DTag_SyncContentHash = 120,
+ ndn_BinaryXml_DTag_SyncLeafCount = 121,
+ ndn_BinaryXml_DTag_SyncTreeDepth = 122,
+ ndn_BinaryXml_DTag_SyncByteCount = 123,
+ ndn_BinaryXml_DTag_SyncConfigSlice = 124,
+ ndn_BinaryXml_DTag_SyncConfigSliceList = 125,
+ ndn_BinaryXml_DTag_SyncConfigSliceOp = 126,
+ ndn_BinaryXml_DTag_SyncNodeDeltas = 127,
+ ndn_BinaryXml_DTag_SequenceNumber = 256,
+ ndn_BinaryXml_DTag_CCNProtocolDataUnit = 17702112
};
#ifdef __cplusplus
diff --git a/ndn-cpp/c/encoding/BinaryXMLContentObject.c b/ndn-cpp/c/encoding/BinaryXMLContentObject.c
index c9104ff..d95889c 100644
--- a/ndn-cpp/c/encoding/BinaryXMLContentObject.c
+++ b/ndn-cpp/c/encoding/BinaryXMLContentObject.c
@@ -10,67 +10,67 @@
#include "BinaryXMLPublisherPublicKeyDigest.h"
#include "BinaryXMLContentObject.h"
-static ndn_Error encodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXMLEncoder *encoder)
+static ndn_Error encodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXmlEncoder *encoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Signature))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Signature))
return error;
// TODO: Check if digestAlgorithm is the same as the default, and skip it, otherwise encode it as UDATA.
- if (error = ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_Witness, signature->witness, signature->witnessLength))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_Witness, signature->witness, signature->witnessLength))
return error;
// Require a signature.
- if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_SignatureBits, signature->signature, signature->signatureLength))
+ if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_SignatureBits, signature->signature, signature->signatureLength))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
return 0;
}
-static ndn_Error decodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXMLDecoder *decoder)
+static ndn_Error decodeSignature(struct ndn_Signature *signature, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Signature))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Signature))
return error;
/* TODO: digestAlgorithm as UDATA */ signature->digestAlgorithm = 0; signature->digestAlgorithmLength = 0;
- if (error = ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_Witness, 0, &signature->witness, &signature->witnessLength))
+ if (error = ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_Witness, 0, &signature->witness, &signature->witnessLength))
return error;
// Require a signature.
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_SignatureBits, 0, &signature->signature, &signature->signatureLength))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_SignatureBits, 0, &signature->signature, &signature->signatureLength))
return error;
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
return 0;
}
-static ndn_Error encodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXMLEncoder *encoder)
+static ndn_Error encodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXmlEncoder *encoder)
{
if (signedInfo->type < 0)
return;
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_SignedInfo))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_SignedInfo))
return error;
// This will skip encoding if there is no publisherPublicKeyDigest.
- if (error = ndn_encodeBinaryXMLPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, encoder))
+ if (error = ndn_encodeBinaryXmlPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, encoder))
return error;
- if (error = ndn_BinaryXMLEncoder_writeOptionalTimeMillisecondsDTagElement
- (encoder, ndn_BinaryXML_DTag_Timestamp, signedInfo->timestampMilliseconds))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalTimeMillisecondsDTagElement
+ (encoder, ndn_BinaryXml_DTag_Timestamp, signedInfo->timestampMilliseconds))
return error;
if (signedInfo->type != ndn_ContentType_DATA) {
@@ -78,90 +78,90 @@
// TODO: Implement converting the type from an int and encoding.
}
- if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
- (encoder, ndn_BinaryXML_DTag_FreshnessSeconds, signedInfo->freshnessSeconds))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+ (encoder, ndn_BinaryXml_DTag_FreshnessSeconds, signedInfo->freshnessSeconds))
return error;
- if (error = ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_FinalBlockID, signedInfo->finalBlockID, signedInfo->finalBlockIDLength))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_FinalBlockID, signedInfo->finalBlockID, signedInfo->finalBlockIDLength))
return error;
// This will skip encoding if there is no key locator.
- if (error = ndn_encodeBinaryXMLKeyLocator(&signedInfo->keyLocator, encoder))
+ if (error = ndn_encodeBinaryXmlKeyLocator(&signedInfo->keyLocator, encoder))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
return 0;
}
-static ndn_Error decodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXMLDecoder *decoder)
+static ndn_Error decodeSignedInfo(struct ndn_SignedInfo *signedInfo, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_SignedInfo))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_SignedInfo))
return error;
- if (error = ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, decoder))
+ if (error = ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest(&signedInfo->publisherPublicKeyDigest, decoder))
return error;
- if (error= ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
- (decoder, ndn_BinaryXML_DTag_Timestamp, &signedInfo->timestampMilliseconds))
+ if (error= ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+ (decoder, ndn_BinaryXml_DTag_Timestamp, &signedInfo->timestampMilliseconds))
return error;
// TODO: Implement reading the type and converting to an int.
signedInfo->type = ndn_ContentType_DATA;
- if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (decoder, ndn_BinaryXML_DTag_FreshnessSeconds, &signedInfo->freshnessSeconds))
+ if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (decoder, ndn_BinaryXml_DTag_FreshnessSeconds, &signedInfo->freshnessSeconds))
return error;
- if (error = ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_FinalBlockID, 0, &signedInfo->finalBlockID, &signedInfo->finalBlockIDLength))
+ if (error = ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_FinalBlockID, 0, &signedInfo->finalBlockID, &signedInfo->finalBlockIDLength))
return error;
- if (error = ndn_decodeOptionalBinaryXMLKeyLocator(&signedInfo->keyLocator, decoder))
+ if (error = ndn_decodeOptionalBinaryXmlKeyLocator(&signedInfo->keyLocator, decoder))
return error;
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
return 0;
}
-ndn_Error ndn_encodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlEncoder *encoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_ContentObject))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_ContentObject))
return error;
if (error = encodeSignature(&contentObject->signature, encoder))
return 0;
- if (error = ndn_encodeBinaryXMLName(&contentObject->name, encoder))
+ if (error = ndn_encodeBinaryXmlName(&contentObject->name, encoder))
return error;
if (error = encodeSignedInfo(&contentObject->signedInfo, encoder))
return 0;
- if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_Content, contentObject->content, contentObject->contentLength))
+ if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_Content, contentObject->content, contentObject->contentLength))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
return 0;
}
-ndn_Error ndn_decodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_ContentObject))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_ContentObject))
return error;
int gotExpectedTag;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Signature, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Signature, &gotExpectedTag))
return error;
if (gotExpectedTag) {
if (error = decodeSignature(&contentObject->signature, decoder))
@@ -170,10 +170,10 @@
else
ndn_Signature_init(&contentObject->signature);
- if (error = ndn_decodeBinaryXMLName(&contentObject->name, decoder))
+ if (error = ndn_decodeBinaryXmlName(&contentObject->name, decoder))
return error;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_SignedInfo, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_SignedInfo, &gotExpectedTag))
return error;
if (gotExpectedTag) {
if (error = decodeSignedInfo(&contentObject->signedInfo, decoder))
@@ -183,11 +183,11 @@
ndn_SignedInfo_init(&contentObject->signedInfo);
// Require a Content element, but set allowNull to allow a missing BLOB.
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_Content, 1, &contentObject->content, &contentObject->contentLength))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_Content, 1, &contentObject->content, &contentObject->contentLength))
return error;
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLContentObject.h b/ndn-cpp/c/encoding/BinaryXMLContentObject.h
index b6444bb..eb7cc5e 100644
--- a/ndn-cpp/c/encoding/BinaryXMLContentObject.h
+++ b/ndn-cpp/c/encoding/BinaryXMLContentObject.h
@@ -15,9 +15,9 @@
extern "C" {
#endif
-ndn_Error ndn_encodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlEncoder *encoder);
-ndn_Error ndn_decodeBinaryXMLContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlContentObject(struct ndn_ContentObject *contentObject, struct ndn_BinaryXmlDecoder *decoder);
#ifdef __cplusplus
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLDecoder.c b/ndn-cpp/c/encoding/BinaryXMLDecoder.c
index 23dd67d..a44af26 100644
--- a/ndn-cpp/c/encoding/BinaryXMLDecoder.c
+++ b/ndn-cpp/c/encoding/BinaryXMLDecoder.c
@@ -11,7 +11,7 @@
* Return the octet at self->offset, converting to unsigned int. Increment self->offset.
* This does not check for reading past the end of the input, so this is called "unsafe".
*/
-static inline unsigned int unsafeReadOctet(struct ndn_BinaryXMLDecoder *self)
+static inline unsigned int unsafeReadOctet(struct ndn_BinaryXmlDecoder *self)
{
return (unsigned int)(self->input[self->offset++] & 0xff);
}
@@ -20,7 +20,7 @@
* Return the octet at self->offset, converting to unsigned int. Do not increment self->offset.
* This does not check for reading past the end of the input, so this is called "unsafe".
*/
-static inline unsigned int unsafeGetOctet(struct ndn_BinaryXMLDecoder *self)
+static inline unsigned int unsafeGetOctet(struct ndn_BinaryXmlDecoder *self)
{
return (unsigned int)(self->input[self->offset] & 0xff);
}
@@ -51,7 +51,7 @@
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_decodeTypeAndValue(struct ndn_BinaryXMLDecoder *self, unsigned int *type, unsigned int *valueOut)
+ndn_Error ndn_BinaryXmlDecoder_decodeTypeAndValue(struct ndn_BinaryXmlDecoder *self, unsigned int *type, unsigned int *valueOut)
{
unsigned int value = 0;
int gotFirstOctet = 0;
@@ -69,29 +69,29 @@
gotFirstOctet = 1;
}
- if (octet & ndn_BinaryXML_TT_FINAL) {
+ if (octet & ndn_BinaryXml_TT_FINAL) {
// Finished.
- *type = octet & ndn_BinaryXML_TT_MASK;
- value = (value << ndn_BinaryXML_TT_VALUE_BITS) | ((octet >> ndn_BinaryXML_TT_BITS) & ndn_BinaryXML_TT_VALUE_MASK);
+ *type = octet & ndn_BinaryXml_TT_MASK;
+ value = (value << ndn_BinaryXml_TT_VALUE_BITS) | ((octet >> ndn_BinaryXml_TT_BITS) & ndn_BinaryXml_TT_VALUE_MASK);
break;
}
- value = (value << ndn_BinaryXML_REGULAR_VALUE_BITS) | (octet & ndn_BinaryXML_REGULAR_VALUE_MASK);
+ value = (value << ndn_BinaryXml_REGULAR_VALUE_BITS) | (octet & ndn_BinaryXml_REGULAR_VALUE_MASK);
}
*valueOut = value;
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readElementStartDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag)
+ndn_Error ndn_BinaryXmlDecoder_readElementStartDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag)
{
ndn_Error error;
unsigned int type;
unsigned int value;
- if (error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &type, &value))
+ if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &type, &value))
return error;
- if (type != ndn_BinaryXML_DTAG)
+ if (type != ndn_BinaryXml_DTAG)
return NDN_ERROR_header_type_is_not_a_DTAG;
if (value != expectedTag)
@@ -100,18 +100,18 @@
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readElementClose(struct ndn_BinaryXMLDecoder *self)
+ndn_Error ndn_BinaryXmlDecoder_readElementClose(struct ndn_BinaryXmlDecoder *self)
{
if (self->offset >= self->inputLength)
return NDN_ERROR_read_past_the_end_of_the_input;
- if (unsafeReadOctet(self) != ndn_BinaryXML_CLOSE)
+ if (unsafeReadOctet(self) != ndn_BinaryXml_CLOSE)
return NDN_ERROR_did_not_get_the_expected_element_close;
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_peekDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *gotExpectedTag)
+ndn_Error ndn_BinaryXmlDecoder_peekDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *gotExpectedTag)
{
// Default to 0.
*gotExpectedTag = 0;
@@ -125,31 +125,31 @@
unsigned int type;
unsigned int value;
unsigned int saveOffset = self->offset;
- ndn_Error error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &type, &value);
+ ndn_Error error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &type, &value);
// Restore offset.
self->offset = saveOffset;
if (error)
return error;
- if (type == ndn_BinaryXML_DTAG && value == expectedTag)
+ if (type == ndn_BinaryXml_DTAG && value == expectedTag)
*gotExpectedTag = 1;
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readBinaryDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
+ndn_Error ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(self, expectedTag))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(self, expectedTag))
return error;
if (allowNull) {
if (self->offset >= self->inputLength)
return NDN_ERROR_read_past_the_end_of_the_input;
- if (unsafeGetOctet(self) == ndn_BinaryXML_CLOSE) {
+ if (unsafeGetOctet(self) == ndn_BinaryXml_CLOSE) {
// The binary item is missing, and this is allowed, so read the element close and return a null value.
++self->offset;
*value = 0;
@@ -159,27 +159,27 @@
}
unsigned int itemType;
- if (error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &itemType, valueLength))
+ if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &itemType, valueLength))
return error;
// Ignore itemType.
*value = self->input + self->offset;
self->offset += *valueLength;
- if (error = ndn_BinaryXMLDecoder_readElementClose(self))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(self))
return error;
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
+ndn_Error ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
{
ndn_Error error;
int gotExpectedTag;
- if (error = ndn_BinaryXMLDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
return error;
if (gotExpectedTag) {
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(self, expectedTag, allowNull, value, valueLength))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(self, expectedTag, allowNull, value, valueLength))
return error;
}
else {
@@ -190,34 +190,34 @@
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readUDataDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength)
+ndn_Error ndn_BinaryXmlDecoder_readUDataDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(self, expectedTag))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(self, expectedTag))
return error;
unsigned int itemType;
- if (error = ndn_BinaryXMLDecoder_decodeTypeAndValue(self, &itemType, valueLength))
+ if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &itemType, valueLength))
return error;
- if (itemType != ndn_BinaryXML_UDATA)
+ if (itemType != ndn_BinaryXml_UDATA)
return NDN_ERROR_item_is_not_UDATA;
*value = self->input + self->offset;
self->offset += *valueLength;
- if (error = ndn_BinaryXMLDecoder_readElementClose(self))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(self))
return error;
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned int *value)
+ndn_Error ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned int *value)
{
unsigned char *udataValue;
unsigned int udataValueLength;
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readUDataDTagElement(self, expectedTag, &udataValue, &udataValueLength))
+ if (error = ndn_BinaryXmlDecoder_readUDataDTagElement(self, expectedTag, &udataValue, &udataValueLength))
return error;
if (error = parseUnsignedDecimalInt(udataValue, udataValueLength, value))
@@ -226,12 +226,12 @@
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *value)
+ndn_Error ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *value)
{
int gotExpectedTag;
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
return error;
if (!gotExpectedTag) {
@@ -240,32 +240,32 @@
}
unsigned int unsignedValue;
- if (error = ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement(self, expectedTag, &unsignedValue))
+ if (error = ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement(self, expectedTag, &unsignedValue))
return error;
*value = (int)unsignedValue;
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds)
+ndn_Error ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds)
{
ndn_Error error;
unsigned char *bytes;
unsigned int bytesLength;
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(self, expectedTag, 0, &bytes, &bytesLength))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(self, expectedTag, 0, &bytes, &bytesLength))
return error;
- *milliseconds = 1000.0 * ndn_BinaryXMLDecoder_unsignedBigEndianToDouble(bytes, bytesLength) / 4096.0;
+ *milliseconds = 1000.0 * ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(bytes, bytesLength) / 4096.0;
return 0;
}
-ndn_Error ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds)
+ndn_Error ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds)
{
int gotExpectedTag;
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
return error;
if (!gotExpectedTag) {
@@ -273,13 +273,13 @@
return 0;
}
- if (error = ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement(self, expectedTag, milliseconds))
+ if (error = ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement(self, expectedTag, milliseconds))
return error;
return 0;
}
-double ndn_BinaryXMLDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength)
+double ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength)
{
double result = 0.0;
unsigned int i;
diff --git a/ndn-cpp/c/encoding/BinaryXMLDecoder.h b/ndn-cpp/c/encoding/BinaryXMLDecoder.h
index 130eef4..87e1b7a 100644
--- a/ndn-cpp/c/encoding/BinaryXMLDecoder.h
+++ b/ndn-cpp/c/encoding/BinaryXMLDecoder.h
@@ -12,13 +12,13 @@
extern "C" {
#endif
-struct ndn_BinaryXMLDecoder {
+struct ndn_BinaryXmlDecoder {
unsigned char *input;
unsigned int inputLength;
unsigned int offset;
};
-static inline void ndn_BinaryXMLDecoder_init(struct ndn_BinaryXMLDecoder *self, unsigned char *input, unsigned int inputLength)
+static inline void ndn_BinaryXmlDecoder_init(struct ndn_BinaryXmlDecoder *self, unsigned char *input, unsigned int inputLength)
{
self->input = input;
self->inputLength = inputLength;
@@ -27,45 +27,45 @@
/**
* Decode the header's type and value from self's input starting at offset. Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param type output for the header type
* @param value output for the header value
* @return 0 for success, else an error code for read past the end of the input or if the initial byte is zero
*/
-ndn_Error ndn_BinaryXMLDecoder_decodeTypeAndValue(struct ndn_BinaryXMLDecoder *self, unsigned int *type, unsigned int *value);
+ndn_Error ndn_BinaryXmlDecoder_decodeTypeAndValue(struct ndn_BinaryXmlDecoder *self, unsigned int *type, unsigned int *value);
/**
* Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
* Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @return 0 for success, else an error code, including an error if not the expected tag
*/
-ndn_Error ndn_BinaryXMLDecoder_readElementStartDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag);
+ndn_Error ndn_BinaryXmlDecoder_readElementStartDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag);
/**
* Read one byte from self's input starting at offset, expecting it to be the element close.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @return 0 for success, else an error code, including an error if not the element close
*/
-ndn_Error ndn_BinaryXMLDecoder_readElementClose(struct ndn_BinaryXMLDecoder *self);
+ndn_Error ndn_BinaryXmlDecoder_readElementClose(struct ndn_BinaryXmlDecoder *self);
/**
* Decode the header from self's input starting at offset, and if it is a DTAG where the value is the expectedTag,
* then set gotExpectedTag to 1, else 0. Do not update offset, including if returning an error.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param gotExpectedTag output a 1 if got the expected tag, else 0
* @return 0 for success, else an error code for read past the end of the input
*/
-ndn_Error ndn_BinaryXMLDecoder_peekDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *gotExpectedTag);
+ndn_Error ndn_BinaryXmlDecoder_peekDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *gotExpectedTag);
/**
* Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
* Then read one item of any type (presumably BLOB, UDATA, TAG or ATTR) and return the item's value and length.
* However, if allowNull is 1, then the item may be absent.
* Finally, read the element close. Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param allowNull 1 if the binary item may be missing
* @param value output a pointer to the binary data inside self's input buffer. However, if allowNull is 1 and the
@@ -75,13 +75,13 @@
* @return 0 for success, else an error code, including an error if not the expected tag, or if allowNull is 0
* and the binary data is absent
*/
-ndn_Error ndn_BinaryXMLDecoder_readBinaryDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
+ndn_Error ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
/**
- * Peek at the next element and if it is the expectedTag, call ndn_BinaryXMLDecoder_readBinaryDTagElement.
+ * Peek at the next element and if it is the expectedTag, call ndn_BinaryXmlDecoder_readBinaryDTagElement.
* Otherwise, set value and valueLength to 0.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param allowNull 1 if the binary item may be missing
* @param value output a pointer to the binary data inside self's input buffer. However, if allowNull is 1 and the
@@ -90,69 +90,69 @@
* binary data item is absent, then return 0.
* @return 0 for success, else an error code, including if allowNull is 0 and the binary data is absent
*/
-ndn_Error ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
+ndn_Error ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength);
/**
* Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
* Then read one item expecting it to be type UDATA, and return the item's value and length.
* Finally, read the element close. Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param value output a pointer to the binary data inside self's input buffer.
* @param valueLength output the length of the binary data.
* @return 0 for success, else an error code, including an error if not the expected tag, or if the item is not UDATA.
*/
-ndn_Error ndn_BinaryXMLDecoder_readUDataDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength);
+ndn_Error ndn_BinaryXmlDecoder_readUDataDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength);
/**
* Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
* Then read one item expecting it to be type UDATA, parse it as an unsigned decimal integer and return the integer.
* Finally, read the element close. Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param value output the unsigned integer
* @return 0 for success, else an error code, including an error if not the expected tag, or if the item is not UDATA,
* or can't parse the integer
*/
-ndn_Error ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned int *value);
+ndn_Error ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned int *value);
/**
- * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement.
+ * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement.
* Otherwise, set value to -1.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param value output the unsigned integer cast to int, or -1 if the next element doesn't have expectedTag.
* @return 0 for success, else an error code, including an error if the item is not UDATA,
* or can't parse the integer
*/
-ndn_Error ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *value);
+ndn_Error ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *value);
/**
* Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag.
* Then read one item, parse it as an unsigned big endian integer in 4096 ticks per second, and convert it to milliseconds.
* Finally, read the element close. Update offset.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param milliseconds output the number of milliseconds
* @return 0 for success, else an error code, including an error if not the expected tag
*/
-ndn_Error ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds);
+ndn_Error ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds);
/**
- * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXMLDecoder_readTimeMillisecondsDTagElement.
+ * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement.
* Otherwise, set value to -1.0 .
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param expectedTag the expected value for DTAG
* @param milliseconds output the number of milliseconds, or -1.0 if the next element doesn't have expectedTag.
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
- (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, double *milliseconds);
+ndn_Error ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds);
/**
* Interpret the bytes as an unsigned big endian integer and convert to a double. Don't check for overflow.
@@ -161,14 +161,14 @@
* @param bytesLength the length of bytes
* @return the result
*/
-double ndn_BinaryXMLDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength);
+double ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength);
/**
* Set the offset into the input, used for the next read.
- * @param self pointer to the ndn_BinaryXMLDecoder struct
+ * @param self pointer to the ndn_BinaryXmlDecoder struct
* @param offset the new offset
*/
-static inline void ndn_BinaryXMLDecoder_seek(struct ndn_BinaryXMLDecoder *self, unsigned int offset)
+static inline void ndn_BinaryXmlDecoder_seek(struct ndn_BinaryXmlDecoder *self, unsigned int offset)
{
self->offset = offset;
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLElementReader.c b/ndn-cpp/c/encoding/BinaryXMLElementReader.c
index 169db20..556c376 100644
--- a/ndn-cpp/c/encoding/BinaryXMLElementReader.c
+++ b/ndn-cpp/c/encoding/BinaryXMLElementReader.c
@@ -5,16 +5,16 @@
#include "BinaryXMLElementReader.h"
-ndn_Error ndn_BinaryXMLElementReader_onReceivedData
- (struct ndn_BinaryXMLElementReader *self, unsigned char *data, unsigned int dataLength)
+ndn_Error ndn_BinaryXmlElementReader_onReceivedData
+ (struct ndn_BinaryXmlElementReader *self, unsigned char *data, unsigned int dataLength)
{
// Process multiple objects in the data.
while(1) {
// Scan the input to check if a whole binary XML object has been read.
- ndn_BinaryXMLStructureDecoder_seek(&self->structureDecoder, 0);
+ ndn_BinaryXmlStructureDecoder_seek(&self->structureDecoder, 0);
ndn_Error error;
- if (error = ndn_BinaryXMLStructureDecoder_findElementEnd(&self->structureDecoder, data, dataLength))
+ if (error = ndn_BinaryXmlStructureDecoder_findElementEnd(&self->structureDecoder, data, dataLength))
return error;
if (self->structureDecoder.gotElementEnd) {
// Got the remainder of an element. Report to the caller.
@@ -39,7 +39,7 @@
// Need to read a new object.
data += self->structureDecoder.offset;
dataLength -= self->structureDecoder.offset;
- ndn_BinaryXMLStructureDecoder_init(&self->structureDecoder);
+ ndn_BinaryXmlStructureDecoder_init(&self->structureDecoder);
if (dataLength == 0)
// No more data in the packet.
return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLElementReader.h b/ndn-cpp/c/encoding/BinaryXMLElementReader.h
index 9a80deb..f4501ad 100644
--- a/ndn-cpp/c/encoding/BinaryXMLElementReader.h
+++ b/ndn-cpp/c/encoding/BinaryXMLElementReader.h
@@ -25,7 +25,7 @@
* Initialize an ndn_ElementListener struct to use the onReceivedElement function pointer.
* @param self pointer to the ndn_ElementListener struct
* @param onReceivedElement pointer to a function which is called when an entire binary XML element is received.
- * self is the pointer to this ndn_ElementListener struct. See ndn_BinaryXMLElementReader_onReceivedData.
+ * self is the pointer to this ndn_ElementListener struct. See ndn_BinaryXmlElementReader_onReceivedData.
*/
static inline void ndn_ElementListener_init
(struct ndn_ElementListener *self, void (*onReceivedElement)(struct ndn_ElementListener *self, unsigned char *element, unsigned int elementLength))
@@ -34,33 +34,33 @@
}
/**
- * A BinaryXmlElementReader lets you call ndn_BinaryXMLElementReader_onReceivedData multiple times which uses an
- * ndn_BinaryXMLStructureDecoder to detect the end of a binary XML element and calls
+ * A BinaryXmlElementReader lets you call ndn_BinaryXmlElementReader_onReceivedData multiple times which uses an
+ * ndn_BinaryXmlStructureDecoder to detect the end of a binary XML element and calls
* (*elementListener->onReceivedElement)(element, elementLength) with the element.
* This handles the case where a single call to onReceivedData may contain multiple elements.
*/
-struct ndn_BinaryXMLElementReader {
+struct ndn_BinaryXmlElementReader {
struct ndn_ElementListener *elementListener;
- struct ndn_BinaryXMLStructureDecoder structureDecoder;
+ struct ndn_BinaryXmlStructureDecoder structureDecoder;
int usePartialData;
struct ndn_DynamicUCharArray partialData;
unsigned int partialDataLength;
};
/**
- * Initialize an ndn_BinaryXMLElementReader struct with the elementListener and a buffer for saving partial data.
- * @param self pointer to the ndn_BinaryXMLElementReader struct
- * @param elementListener pointer to the ndn_ElementListener used by ndn_BinaryXMLElementReader_onReceivedData.
+ * Initialize an ndn_BinaryXmlElementReader struct with the elementListener and a buffer for saving partial data.
+ * @param self pointer to the ndn_BinaryXmlElementReader struct
+ * @param elementListener pointer to the ndn_ElementListener used by ndn_BinaryXmlElementReader_onReceivedData.
* @param buffer the allocated buffer. If reallocFunction is null, this should be large enough to save a full element, perhaps 8000 bytes.
* @param bufferLength the length of the buffer
* @param reallocFunction see ndn_DynamicUCharArray_ensureLength. This may be 0.
*/
-static inline void ndn_BinaryXMLElementReader_init
- (struct ndn_BinaryXMLElementReader *self, struct ndn_ElementListener *elementListener,
+static inline void ndn_BinaryXmlElementReader_init
+ (struct ndn_BinaryXmlElementReader *self, struct ndn_ElementListener *elementListener,
unsigned char *buffer, unsigned int bufferLength, unsigned char * (*reallocFunction)(unsigned char *, unsigned int))
{
self->elementListener = elementListener;
- ndn_BinaryXMLStructureDecoder_init(&self->structureDecoder);
+ ndn_BinaryXmlStructureDecoder_init(&self->structureDecoder);
self->usePartialData = 0;
ndn_DynamicUCharArray_init(&self->partialData, buffer, bufferLength, reallocFunction);
}
@@ -68,13 +68,13 @@
/**
* Continue to read binary XML data until the end of an element, then call (*elementListener->onReceivedElement)(element, elementLength).
* The buffer passed to onReceivedElement is only valid during this call. If you need the data later, you must copy.
- * @param self pointer to the ndn_BinaryXMLElementReader struct
+ * @param self pointer to the ndn_BinaryXmlElementReader struct
* @param data pointer to the buffer with the binary XML bytes
* @param dataLength length of data
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLElementReader_onReceivedData
- (struct ndn_BinaryXMLElementReader *self, unsigned char *data, unsigned int dataLength);
+ndn_Error ndn_BinaryXmlElementReader_onReceivedData
+ (struct ndn_BinaryXmlElementReader *self, unsigned char *data, unsigned int dataLength);
#ifdef __cplusplus
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLEncoder.c b/ndn-cpp/c/encoding/BinaryXMLEncoder.c
index b7f1db1..0b38f87 100644
--- a/ndn-cpp/c/encoding/BinaryXMLEncoder.c
+++ b/ndn-cpp/c/encoding/BinaryXMLEncoder.c
@@ -10,20 +10,20 @@
#include "BinaryXMLEncoder.h"
enum {
- ENCODING_LIMIT_1_BYTE = ((1 << ndn_BinaryXML_TT_VALUE_BITS) - 1),
- ENCODING_LIMIT_2_BYTES = ((1 << (ndn_BinaryXML_TT_VALUE_BITS + ndn_BinaryXML_REGULAR_VALUE_BITS)) - 1),
- ENCODING_LIMIT_3_BYTES = ((1 << (ndn_BinaryXML_TT_VALUE_BITS + 2 * ndn_BinaryXML_REGULAR_VALUE_BITS)) - 1)
+ ENCODING_LIMIT_1_BYTE = ((1 << ndn_BinaryXml_TT_VALUE_BITS) - 1),
+ ENCODING_LIMIT_2_BYTES = ((1 << (ndn_BinaryXml_TT_VALUE_BITS + ndn_BinaryXml_REGULAR_VALUE_BITS)) - 1),
+ ENCODING_LIMIT_3_BYTES = ((1 << (ndn_BinaryXml_TT_VALUE_BITS + 2 * ndn_BinaryXml_REGULAR_VALUE_BITS)) - 1)
};
/**
* Call ndn_DynamicUCharArray_ensureLength to ensure that there is enough room in the output, and copy
* array to the output. This does not write a header.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param array the array to copy
* @param arrayLength the length of the array
* @return 0 for success, else an error code
*/
-static ndn_Error writeArray(struct ndn_BinaryXMLEncoder *self, unsigned char *array, unsigned int arrayLength)
+static ndn_Error writeArray(struct ndn_BinaryXmlEncoder *self, unsigned char *array, unsigned int arrayLength)
{
ndn_Error error;
if (error = ndn_DynamicUCharArray_ensureLength(&self->output, self->offset + arrayLength))
@@ -52,10 +52,10 @@
// Last byte gives you TT_VALUE_BITS.
// Remainder each gives you REGULAR_VALUE_BITS.
- x >>= ndn_BinaryXML_TT_VALUE_BITS;
+ x >>= ndn_BinaryXml_TT_VALUE_BITS;
while (x != 0) {
++nBytes;
- x >>= ndn_BinaryXML_REGULAR_VALUE_BITS;
+ x >>= ndn_BinaryXml_REGULAR_VALUE_BITS;
}
return nBytes;
@@ -88,11 +88,11 @@
* Write x as an unsigned decimal integer to the output with the digits in reverse order, using ndn_DynamicUCharArray_ensureLength.
* This does not write a header.
* We encode in reverse order, because this is the natural way to encode the digits, and the caller can reverse as needed.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param x the unsigned int to write
* @return 0 for success, else an error code
*/
-static ndn_Error encodeReversedUnsignedDecimalInt(struct ndn_BinaryXMLEncoder *self, unsigned int x)
+static ndn_Error encodeReversedUnsignedDecimalInt(struct ndn_BinaryXmlEncoder *self, unsigned int x)
{
while (1) {
ndn_Error error;
@@ -114,13 +114,13 @@
* then encode the header at startOffset.
* startOffser it the position in self-output.array of the first byte of the buffer and self->offset is the first byte past the end.
* We reverse and shift in the same function to avoid unnecessary copying if we first reverse then shift.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param startOffset the offset in self->output.array of the start of the buffer to shift right
* @param type the header type
* @return 0 for success, else an error code
*/
static ndn_Error reverseBufferAndInsertHeader
- (struct ndn_BinaryXMLEncoder *self, unsigned int startOffset, unsigned int type)
+ (struct ndn_BinaryXmlEncoder *self, unsigned int startOffset, unsigned int type)
{
unsigned int nBufferBytes = self->offset - startOffset;
unsigned int nHeaderBytes = getNHeaderEncodingBytes(nBufferBytes);
@@ -141,7 +141,7 @@
// Override the offset to force encodeTypeAndValue to encode at startOffset, then fix the offset.
self->offset = startOffset;
- if (error = ndn_BinaryXMLEncoder_encodeTypeAndValue(self, ndn_BinaryXML_UDATA, nBufferBytes))
+ if (error = ndn_BinaryXmlEncoder_encodeTypeAndValue(self, ndn_BinaryXml_UDATA, nBufferBytes))
// We don't really expect to get an error, since we have already ensured the length.
return error;
self->offset = startOffset + nHeaderBytes + nBufferBytes;
@@ -170,9 +170,9 @@
*hi32 = (unsigned long)((x - lo32Double) / twoPower32);
}
-ndn_Error ndn_BinaryXMLEncoder_encodeTypeAndValue(struct ndn_BinaryXMLEncoder *self, unsigned int type, unsigned int value)
+ndn_Error ndn_BinaryXmlEncoder_encodeTypeAndValue(struct ndn_BinaryXmlEncoder *self, unsigned int type, unsigned int value)
{
- if (type > ndn_BinaryXML_UDATA)
+ if (type > ndn_BinaryXml_UDATA)
return NDN_ERROR_header_type_is_out_of_range;
// Encode backwards. Calculate how many bytes we need.
@@ -183,16 +183,16 @@
// Bottom 4 bits of value go in last byte with tag.
self->output.array[self->offset + nEncodingBytes - 1] =
- (ndn_BinaryXML_TT_MASK & type |
- ((ndn_BinaryXML_TT_VALUE_MASK & value) << ndn_BinaryXML_TT_BITS)) |
- ndn_BinaryXML_TT_FINAL; // set top bit for last byte
- value >>= ndn_BinaryXML_TT_VALUE_BITS;
+ (ndn_BinaryXml_TT_MASK & type |
+ ((ndn_BinaryXml_TT_VALUE_MASK & value) << ndn_BinaryXml_TT_BITS)) |
+ ndn_BinaryXml_TT_FINAL; // set top bit for last byte
+ value >>= ndn_BinaryXml_TT_VALUE_BITS;
// Rest of value goes into preceding bytes, 7 bits per byte. (Zero top bit is "more" flag.)
unsigned int i = self->offset + nEncodingBytes - 2;
while (value != 0 && i >= self->offset) {
- self->output.array[i] = (value & ndn_BinaryXML_REGULAR_VALUE_MASK);
- value >>= ndn_BinaryXML_REGULAR_VALUE_BITS;
+ self->output.array[i] = (value & ndn_BinaryXml_REGULAR_VALUE_MASK);
+ value >>= ndn_BinaryXml_REGULAR_VALUE_BITS;
--i;
}
if (value != 0)
@@ -204,22 +204,22 @@
return 0;
}
-ndn_Error ndn_BinaryXMLEncoder_writeElementClose(struct ndn_BinaryXMLEncoder *self)
+ndn_Error ndn_BinaryXmlEncoder_writeElementClose(struct ndn_BinaryXmlEncoder *self)
{
ndn_Error error;
if (error = ndn_DynamicUCharArray_ensureLength(&self->output, self->offset + 1))
return error;
- self->output.array[self->offset] = ndn_BinaryXML_CLOSE;
+ self->output.array[self->offset] = ndn_BinaryXml_CLOSE;
self->offset += 1;
return 0;
}
-ndn_Error ndn_BinaryXMLEncoder_writeBlob(struct ndn_BinaryXMLEncoder *self, unsigned char *value, unsigned int valueLength)
+ndn_Error ndn_BinaryXmlEncoder_writeBlob(struct ndn_BinaryXmlEncoder *self, unsigned char *value, unsigned int valueLength)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_encodeTypeAndValue(self, ndn_BinaryXML_BLOB, valueLength))
+ if (error = ndn_BinaryXmlEncoder_encodeTypeAndValue(self, ndn_BinaryXml_BLOB, valueLength))
return error;
if (error = writeArray(self, value, valueLength))
@@ -228,22 +228,22 @@
return 0;
}
-ndn_Error ndn_BinaryXMLEncoder_writeBlobDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
+ndn_Error ndn_BinaryXmlEncoder_writeBlobDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(self, tag))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(self, tag))
return error;
- if (error = ndn_BinaryXMLEncoder_writeBlob(self, value, valueLength))
+ if (error = ndn_BinaryXmlEncoder_writeBlob(self, value, valueLength))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(self))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(self))
return error;
return 0;
}
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXMLEncoder *self, unsigned int value)
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXmlEncoder *self, unsigned int value)
{
// First write the decimal int (to find out how many bytes it is), then shift it forward to make room for the header.
unsigned int startOffset = self->offset;
@@ -252,28 +252,28 @@
if (error = encodeReversedUnsignedDecimalInt(self, value))
return error;
- if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXML_UDATA))
+ if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXml_UDATA))
return error;
return 0;
}
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned int value)
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned int value)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(self, tag))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(self, tag))
return error;
- if (error = ndn_BinaryXMLEncoder_writeUnsignedDecimalInt(self, value))
+ if (error = ndn_BinaryXmlEncoder_writeUnsignedDecimalInt(self, value))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(self))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(self))
return error;
return 0;
}
-ndn_Error ndn_BinaryXMLEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXMLEncoder *self, double value)
+ndn_Error ndn_BinaryXmlEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXmlEncoder *self, double value)
{
unsigned long hi32, lo32;
splitAbsDouble(value, &hi32, &lo32);
@@ -309,22 +309,22 @@
}
}
- if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXML_BLOB))
+ if (error = reverseBufferAndInsertHeader(self, startOffset, ndn_BinaryXml_BLOB))
return error;
return 0;
}
-ndn_Error ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, double milliseconds)
+ndn_Error ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, double milliseconds)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(self, tag))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(self, tag))
return error;
- if (error = ndn_BinaryXMLEncoder_writeAbsDoubleBigEndianBlob(self, (milliseconds / 1000.0) * 4096.0))
+ if (error = ndn_BinaryXmlEncoder_writeAbsDoubleBigEndianBlob(self, (milliseconds / 1000.0) * 4096.0))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(self))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(self))
return error;
return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLEncoder.h b/ndn-cpp/c/encoding/BinaryXMLEncoder.h
index ac20ae8..c300d17 100644
--- a/ndn-cpp/c/encoding/BinaryXMLEncoder.h
+++ b/ndn-cpp/c/encoding/BinaryXMLEncoder.h
@@ -14,24 +14,24 @@
extern "C" {
#endif
-/** An ndn_BinaryXMLEncoder struct is used by all the encoding functions. You should initialize it with
- * ndn_BinaryXMLEncoder_init.
+/** An ndn_BinaryXmlEncoder struct is used by all the encoding functions. You should initialize it with
+ * ndn_BinaryXmlEncoder_init.
*/
-struct ndn_BinaryXMLEncoder {
+struct ndn_BinaryXmlEncoder {
struct ndn_DynamicUCharArray output; /**< receives the encoded output */
unsigned int offset; /**< the offset into output.array for the next encoding */
};
/**
- * Initialize an ndn_BinaryXMLEncoder_init struct with the arguments for initializing the ndn_DynamicUCharArray.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * Initialize an ndn_BinaryXmlEncoder_init struct with the arguments for initializing the ndn_DynamicUCharArray.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param outputArray the allocated array buffer to receive the encoding
* @param outputArrayLength the length of outputArray
* @param reallocFunction the realloc function used by ndn_DynamicUCharArray_ensureLength. If outputArrayLength
* is large enough to receive the entire encoding, this can be 0.
*/
-static inline void ndn_BinaryXMLEncoder_init
- (struct ndn_BinaryXMLEncoder *self, unsigned char *outputArray, unsigned int outputArrayLength,
+static inline void ndn_BinaryXmlEncoder_init
+ (struct ndn_BinaryXmlEncoder *self, unsigned char *outputArray, unsigned int outputArrayLength,
unsigned char * (*reallocFunction)(unsigned char *, unsigned int))
{
ndn_DynamicUCharArray_init(&self->output, outputArray, outputArrayLength, reallocFunction);
@@ -40,134 +40,134 @@
/**
* Encode a header with the type and value and write it to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param type the header type
* @param value the header value
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_encodeTypeAndValue(struct ndn_BinaryXMLEncoder *self, unsigned int type, unsigned int value);
+ndn_Error ndn_BinaryXmlEncoder_encodeTypeAndValue(struct ndn_BinaryXmlEncoder *self, unsigned int type, unsigned int value);
/**
* Write an element start header using DTAG with the tag to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param tag the DTAG tag
* @return 0 for success, else an error code
*/
-static inline ndn_Error ndn_BinaryXMLEncoder_writeElementStartDTag(struct ndn_BinaryXMLEncoder *self, unsigned int tag)
+static inline ndn_Error ndn_BinaryXmlEncoder_writeElementStartDTag(struct ndn_BinaryXmlEncoder *self, unsigned int tag)
{
- return ndn_BinaryXMLEncoder_encodeTypeAndValue(self, ndn_BinaryXML_DTAG, tag);
+ return ndn_BinaryXmlEncoder_encodeTypeAndValue(self, ndn_BinaryXml_DTAG, tag);
}
/**
* Write an element close to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_writeElementClose(struct ndn_BinaryXMLEncoder *self);
+ndn_Error ndn_BinaryXmlEncoder_writeElementClose(struct ndn_BinaryXmlEncoder *self);
/**
* Write a BLOB header, then the bytes of the blob value to self->output.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param value an array of bytes for the blob value
* @param valueLength the length of the array
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_writeBlob(struct ndn_BinaryXMLEncoder *self, unsigned char *value, unsigned int valueLength);
+ndn_Error ndn_BinaryXmlEncoder_writeBlob(struct ndn_BinaryXmlEncoder *self, unsigned char *value, unsigned int valueLength);
/**
* Write an element start header using DTAG with the tag to self->output, then the blob, then an element close.
- * (If you want to just write the blob, use ndn_BinaryXMLEncoder_writeBlob .)
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * (If you want to just write the blob, use ndn_BinaryXmlEncoder_writeBlob .)
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param tag the DTAG tag
* @param value an array of bytes for the blob value
* @param valueLength the length of the array
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_writeBlobDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength);
+ndn_Error ndn_BinaryXmlEncoder_writeBlobDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength);
/**
- * If value or valueLen is 0 then do nothing, otherwise call ndn_BinaryXMLEncoder_writeBlobDTagElement.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * If value or valueLen is 0 then do nothing, otherwise call ndn_BinaryXmlEncoder_writeBlobDTagElement.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param tag the DTAG tag
* @param value an array of bytes for the blob value
* @param valueLength the length of the array
* @return 0 for success, else an error code
*/
-static inline ndn_Error ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
- (struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
+static inline ndn_Error ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+ (struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned char *value, unsigned int valueLength)
{
if (value && valueLength > 0)
- return ndn_BinaryXMLEncoder_writeBlobDTagElement(self, tag, value, valueLength);
+ return ndn_BinaryXmlEncoder_writeBlobDTagElement(self, tag, value, valueLength);
else
return (ndn_Error)0;
}
/**
* Write a UDATA header, then the value as an unsigned decimal integer.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param value the unsigned int
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXMLEncoder *self, unsigned int value);
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalInt(struct ndn_BinaryXmlEncoder *self, unsigned int value);
/**
* Write an element start header using DTAG with the tag to self->output, then the value as an unsigned decimal integer,
* then an element close.
- * (If you want to just write the integer, use ndn_BinaryXMLEncoder_writeUnsignedDecimalInt .)
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * (If you want to just write the integer, use ndn_BinaryXmlEncoder_writeUnsignedDecimalInt .)
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param tag the DTAG tag
* @param value the unsigned int
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, unsigned int value);
+ndn_Error ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, unsigned int value);
/**
- * If value is negative then do nothing, otherwise call ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * If value is negative then do nothing, otherwise call ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param tag the DTAG tag
* @param value negative for none, otherwise use (unsigned int)value
* @return 0 for success, else an error code
*/
-static inline ndn_Error ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, int value)
+static inline ndn_Error ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, int value)
{
if (value >= 0)
- return ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement(self, tag, (unsigned int)value);
+ return ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement(self, tag, (unsigned int)value);
else
return (ndn_Error)0;
}
/**
* Write a BLOB header, then the absolute value of value to self->output encoded as big endian.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param value the double to encode as big endian. If value is 0, the big endian encoding has zero bytes.
* The value is converted to absolute value.
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXMLEncoder *self, double value);
+ndn_Error ndn_BinaryXmlEncoder_writeAbsDoubleBigEndianBlob(struct ndn_BinaryXmlEncoder *self, double value);
/**
* Write an element start header using DTAG with the tag to self->output, then the absolute value of milliseconds
* as a big endian BLOB converted to 4096 ticks per second, then an element close.
- * (If you want to just write the integer, use ndn_BinaryXMLEncoder_writeUnsignedDecimalInt .)
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * (If you want to just write the integer, use ndn_BinaryXmlEncoder_writeUnsignedDecimalInt .)
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param tag the DTAG tag
* @param milliseconds the the number of milliseconds
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXMLEncoder *self, unsigned int tag, double milliseconds);
+ndn_Error ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement(struct ndn_BinaryXmlEncoder *self, unsigned int tag, double milliseconds);
/**
- * If milliseconds is negative then do nothing, otherwise call ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement.
- * @param self pointer to the ndn_BinaryXMLEncoder struct
+ * If milliseconds is negative then do nothing, otherwise call ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement.
+ * @param self pointer to the ndn_BinaryXmlEncoder struct
* @param tag the DTAG tag
* @param milliseconds negative for none, otherwise the number of milliseconds
* @return 0 for success, else an error code
*/
-static inline ndn_Error ndn_BinaryXMLEncoder_writeOptionalTimeMillisecondsDTagElement
- (struct ndn_BinaryXMLEncoder *self, unsigned int tag, double milliseconds)
+static inline ndn_Error ndn_BinaryXmlEncoder_writeOptionalTimeMillisecondsDTagElement
+ (struct ndn_BinaryXmlEncoder *self, unsigned int tag, double milliseconds)
{
if (milliseconds >= 0)
- return ndn_BinaryXMLEncoder_writeTimeMillisecondsDTagElement(self, tag, milliseconds);
+ return ndn_BinaryXmlEncoder_writeTimeMillisecondsDTagElement(self, tag, milliseconds);
else
return (ndn_Error)0;
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLInterest.c b/ndn-cpp/c/encoding/BinaryXMLInterest.c
index 713d4f2..953f76d 100644
--- a/ndn-cpp/c/encoding/BinaryXMLInterest.c
+++ b/ndn-cpp/c/encoding/BinaryXMLInterest.c
@@ -10,13 +10,13 @@
#include "BinaryXMLPublisherPublicKeyDigest.h"
#include "BinaryXMLInterest.h"
-static ndn_Error encodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXMLEncoder *encoder)
+static ndn_Error encodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXmlEncoder *encoder)
{
if (exclude->nEntries == 0)
return 0;
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Exclude))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Exclude))
return error;
// TODO: Do we want to order the components (except for ANY)?
@@ -25,43 +25,43 @@
struct ndn_ExcludeEntry *entry = &exclude->entries[i];
if (entry->type == ndn_Exclude_COMPONENT) {
- if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_Component, entry->component, entry->componentLength))
+ if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_Component, entry->component, entry->componentLength))
return error;
}
else if (entry->type == ndn_Exclude_ANY) {
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Any))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Any))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
}
else
return NDN_ERROR_unrecognized_ndn_ExcludeType;
}
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
return 0;
}
-static ndn_Error decodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXMLDecoder *decoder)
+static ndn_Error decodeExclude(struct ndn_Exclude *exclude, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Exclude))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Exclude))
return error;
exclude->nEntries = 0;
while (1) {
int gotExpectedTag;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Component, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Component, &gotExpectedTag))
return error;
if (gotExpectedTag) {
// Component
unsigned char *component;
unsigned int componentLen;
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(decoder, ndn_BinaryXML_DTag_Component, 0, &component, &componentLen))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(decoder, ndn_BinaryXml_DTag_Component, 0, &component, &componentLen))
return error;
// Add the component entry.
@@ -73,13 +73,13 @@
continue;
}
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Any, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Any, &gotExpectedTag))
return error;
if (gotExpectedTag) {
// Any
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Any))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Any))
return error;
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
// Add the any entry.
@@ -91,13 +91,13 @@
continue;
}
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Bloom, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Bloom, &gotExpectedTag))
return error;
if (gotExpectedTag) {
// Skip the Bloom and treat it as Any.
unsigned char *value;
unsigned int valueLen;
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(decoder, ndn_BinaryXML_DTag_Bloom, 0, &value, &valueLen))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(decoder, ndn_BinaryXml_DTag_Bloom, 0, &value, &valueLen))
return error;
// Add the any entry.
@@ -113,83 +113,83 @@
break;
}
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
return 0;
}
-ndn_Error ndn_encodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlEncoder *encoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Interest))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Interest))
return error;
- if (error = ndn_encodeBinaryXMLName(&interest->name, encoder))
+ if (error = ndn_encodeBinaryXmlName(&interest->name, encoder))
return error;
- if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
- (encoder, ndn_BinaryXML_DTag_MinSuffixComponents, interest->minSuffixComponents))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+ (encoder, ndn_BinaryXml_DTag_MinSuffixComponents, interest->minSuffixComponents))
return error;
- if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
- (encoder, ndn_BinaryXML_DTag_MaxSuffixComponents, interest->maxSuffixComponents))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+ (encoder, ndn_BinaryXml_DTag_MaxSuffixComponents, interest->maxSuffixComponents))
return error;
// This will skip encoding if there is no publisherPublicKeyDigest.
- if (error = ndn_encodeBinaryXMLPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, encoder))
+ if (error = ndn_encodeBinaryXmlPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, encoder))
return error;
// This will skip encoding if there is no exclude.
if (error = encodeExclude(&interest->exclude, encoder))
return error;
- if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
- (encoder, ndn_BinaryXML_DTag_ChildSelector, interest->childSelector))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+ (encoder, ndn_BinaryXml_DTag_ChildSelector, interest->childSelector))
return error;
if (interest->answerOriginKind >= 0 && interest->answerOriginKind != ndn_Interest_DEFAULT_ANSWER_ORIGIN_KIND) {
- if (error = ndn_BinaryXMLEncoder_writeUnsignedDecimalIntDTagElement
- (encoder, ndn_BinaryXML_DTag_AnswerOriginKind, (unsigned int)interest->answerOriginKind))
+ if (error = ndn_BinaryXmlEncoder_writeUnsignedDecimalIntDTagElement
+ (encoder, ndn_BinaryXml_DTag_AnswerOriginKind, (unsigned int)interest->answerOriginKind))
return error;
}
- if (error = ndn_BinaryXMLEncoder_writeOptionalUnsignedDecimalIntDTagElement
- (encoder, ndn_BinaryXML_DTag_Scope, interest->scope))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalUnsignedDecimalIntDTagElement
+ (encoder, ndn_BinaryXml_DTag_Scope, interest->scope))
return error;
- if (error = ndn_BinaryXMLEncoder_writeOptionalTimeMillisecondsDTagElement
- (encoder, ndn_BinaryXML_DTag_InterestLifetime, interest->interestLifetimeMilliseconds))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalTimeMillisecondsDTagElement
+ (encoder, ndn_BinaryXml_DTag_InterestLifetime, interest->interestLifetimeMilliseconds))
return error;
- if (error = ndn_BinaryXMLEncoder_writeOptionalBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_Nonce, interest->nonce, interest->nonceLength))
+ if (error = ndn_BinaryXmlEncoder_writeOptionalBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_Nonce, interest->nonce, interest->nonceLength))
return error;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
return 0;
}
-ndn_Error ndn_decodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Interest))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Interest))
return error;
- if (error = ndn_decodeBinaryXMLName(&interest->name, decoder))
+ if (error = ndn_decodeBinaryXmlName(&interest->name, decoder))
return error;
- if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (decoder, ndn_BinaryXML_DTag_MinSuffixComponents, &interest->minSuffixComponents))
+ if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (decoder, ndn_BinaryXml_DTag_MinSuffixComponents, &interest->minSuffixComponents))
return error;
- if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (decoder, ndn_BinaryXML_DTag_MaxSuffixComponents, &interest->maxSuffixComponents))
+ if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (decoder, ndn_BinaryXml_DTag_MaxSuffixComponents, &interest->maxSuffixComponents))
return error;
- if (error = ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, decoder))
+ if (error = ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest(&interest->publisherPublicKeyDigest, decoder))
return error;
int gotExpectedTag;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Exclude, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Exclude, &gotExpectedTag))
return error;
if (gotExpectedTag) {
if (error = decodeExclude(&interest->exclude, decoder))
@@ -198,25 +198,25 @@
else
interest->exclude.nEntries = 0;
- if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (decoder, ndn_BinaryXML_DTag_ChildSelector, &interest->childSelector))
+ if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (decoder, ndn_BinaryXml_DTag_ChildSelector, &interest->childSelector))
return error;
- if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (decoder, ndn_BinaryXML_DTag_AnswerOriginKind, &interest->answerOriginKind))
+ if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (decoder, ndn_BinaryXml_DTag_AnswerOriginKind, &interest->answerOriginKind))
return error;
- if (error = ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement
- (decoder, ndn_BinaryXML_DTag_Scope, &interest->scope))
+ if (error = ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (decoder, ndn_BinaryXml_DTag_Scope, &interest->scope))
return error;
- if (error= ndn_BinaryXMLDecoder_readOptionalTimeMillisecondsDTagElement
- (decoder, ndn_BinaryXML_DTag_InterestLifetime, &interest->interestLifetimeMilliseconds))
+ if (error= ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+ (decoder, ndn_BinaryXml_DTag_InterestLifetime, &interest->interestLifetimeMilliseconds))
return error;
- if (error = ndn_BinaryXMLDecoder_readOptionalBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_Nonce, 0, &interest->nonce, &interest->nonceLength))
+ if (error = ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_Nonce, 0, &interest->nonce, &interest->nonceLength))
return error;
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLInterest.h b/ndn-cpp/c/encoding/BinaryXMLInterest.h
index 9a58b78..960871f 100644
--- a/ndn-cpp/c/encoding/BinaryXMLInterest.h
+++ b/ndn-cpp/c/encoding/BinaryXMLInterest.h
@@ -15,9 +15,9 @@
extern "C" {
#endif
-ndn_Error ndn_encodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlEncoder *encoder);
-ndn_Error ndn_decodeBinaryXMLInterest(struct ndn_Interest *interest, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlInterest(struct ndn_Interest *interest, struct ndn_BinaryXmlDecoder *decoder);
#ifdef __cplusplus
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLKey.c b/ndn-cpp/c/encoding/BinaryXMLKey.c
index b7583ef..e7e7f41 100644
--- a/ndn-cpp/c/encoding/BinaryXMLKey.c
+++ b/ndn-cpp/c/encoding/BinaryXMLKey.c
@@ -8,23 +8,23 @@
#include "BinaryXMLStructureDecoder.h"
#include "BinaryXMLKey.h"
-ndn_Error ndn_encodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlEncoder *encoder)
{
if (keyLocator->type < 0)
return 0;
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_KeyLocator))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_KeyLocator))
return error;
if (keyLocator->type == ndn_KeyLocatorType_KEY) {
- if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_Key, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
+ if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_Key, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
return error;
}
else if (keyLocator->type == ndn_KeyLocatorType_CERTIFICATE) {
- if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_Certificate, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
+ if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_Certificate, keyLocator->keyOrCertificate, keyLocator->keyOrCertificateLength))
return error;
}
else if (keyLocator->type == ndn_KeyLocatorType_KEYNAME) {
@@ -33,72 +33,72 @@
else
return NDN_ERROR_unrecognized_ndn_KeyLocatorType;
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
return 0;
}
-ndn_Error ndn_decodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_KeyLocator))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_KeyLocator))
return error;
int gotExpectedTag;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Key, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Key, &gotExpectedTag))
return error;
if (gotExpectedTag) {
keyLocator->type = ndn_KeyLocatorType_KEY;
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_Key, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_Key, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
return error;
}
else {
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Certificate, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Certificate, &gotExpectedTag))
return error;
if (gotExpectedTag) {
keyLocator->type = ndn_KeyLocatorType_CERTIFICATE;
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_Certificate, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_Certificate, 0, &keyLocator->keyOrCertificate, &keyLocator->keyOrCertificateLength))
return error;
}
else {
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_KeyName, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_KeyName, &gotExpectedTag))
return error;
if (gotExpectedTag) {
// TODO: Implement keyName. For now, just use a structure decoder to skip it.
- struct ndn_BinaryXMLStructureDecoder structureDecoder;
- ndn_BinaryXMLStructureDecoder_init(&structureDecoder);
+ struct ndn_BinaryXmlStructureDecoder structureDecoder;
+ ndn_BinaryXmlStructureDecoder_init(&structureDecoder);
- ndn_BinaryXMLStructureDecoder_seek(&structureDecoder, decoder->offset);
- if (error = ndn_BinaryXMLStructureDecoder_findElementEnd(&structureDecoder, decoder->input, decoder->inputLength))
+ ndn_BinaryXmlStructureDecoder_seek(&structureDecoder, decoder->offset);
+ if (error = ndn_BinaryXmlStructureDecoder_findElementEnd(&structureDecoder, decoder->input, decoder->inputLength))
return error;
if (!structureDecoder.gotElementEnd)
return NDN_ERROR_read_past_the_end_of_the_input;
- ndn_BinaryXMLDecoder_seek(decoder, structureDecoder.offset);
+ ndn_BinaryXmlDecoder_seek(decoder, structureDecoder.offset);
}
else
- return NDN_ERROR_decodeBinaryXMLKeyLocator_unrecognized_key_locator_type;
+ return NDN_ERROR_decodeBinaryXmlKeyLocator_unrecognized_key_locator_type;
}
}
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
return 0;
}
-ndn_Error ndn_decodeOptionalBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeOptionalBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder)
{
int gotExpectedTag;
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_KeyLocator, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_KeyLocator, &gotExpectedTag))
return error;
if (gotExpectedTag) {
- if (error = ndn_decodeBinaryXMLKeyLocator(keyLocator, decoder))
+ if (error = ndn_decodeBinaryXmlKeyLocator(keyLocator, decoder))
return error;
}
else
diff --git a/ndn-cpp/c/encoding/BinaryXMLKey.h b/ndn-cpp/c/encoding/BinaryXMLKey.h
index 8896dd6..8ccbcac 100644
--- a/ndn-cpp/c/encoding/BinaryXMLKey.h
+++ b/ndn-cpp/c/encoding/BinaryXMLKey.h
@@ -18,27 +18,27 @@
/**
* Encode the ndn_KeyLocator struct using Binary XML. If keyLocator->type is -1, then do nothing.
* @param keyLocator pointer to the ndn_KeyLocator struct
- * @param encoder pointer to the ndn_BinaryXMLEncoder struct
+ * @param encoder pointer to the ndn_BinaryXmlEncoder struct
* @return 0 for success, else an error code
*/
-ndn_Error ndn_encodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlEncoder *encoder);
/**
* Expect the next element to be a Binary XML KeyLocator and decode into the ndn_KeyLocator struct.
* @param keyLocator pointer to the ndn_KeyLocator struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
* @return 0 for success, else an error code, including if the next element is not KeyLocator.
*/
-ndn_Error ndn_decodeBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder);
/**
* Peek the next element and if it is a Binary XML KeyLocator and decode into the ndn_KeyLocator struct.
* Otherwise, set the ndn_KeyLocator struct to none.
* @param keyLocator pointer to the ndn_KeyLocator struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
* @return 0 for success, else an error code, including if the next element is not KeyLocator.
*/
-ndn_Error ndn_decodeOptionalBinaryXMLKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeOptionalBinaryXmlKeyLocator(struct ndn_KeyLocator *keyLocator, struct ndn_BinaryXmlDecoder *decoder);
#ifdef __cplusplus
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLName.c b/ndn-cpp/c/encoding/BinaryXMLName.c
index f75c1ea..97adda0 100644
--- a/ndn-cpp/c/encoding/BinaryXMLName.c
+++ b/ndn-cpp/c/encoding/BinaryXMLName.c
@@ -8,35 +8,35 @@
#include "BinaryXMLDecoder.h"
#include "BinaryXMLName.h"
-ndn_Error ndn_encodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlEncoder *encoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeElementStartDTag(encoder, ndn_BinaryXML_DTag_Name))
+ if (error = ndn_BinaryXmlEncoder_writeElementStartDTag(encoder, ndn_BinaryXml_DTag_Name))
return error;
unsigned int i;
for (i = 0; i < name->nComponents; ++i) {
- if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_Component, name->components[i].value, name->components[i].valueLength))
+ if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_Component, name->components[i].value, name->components[i].valueLength))
return error;
}
- if (error = ndn_BinaryXMLEncoder_writeElementClose(encoder))
+ if (error = ndn_BinaryXmlEncoder_writeElementClose(encoder))
return error;
return 0;
}
-ndn_Error ndn_decodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readElementStartDTag(decoder, ndn_BinaryXML_DTag_Name))
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(decoder, ndn_BinaryXml_DTag_Name))
return error;
name->nComponents = 0;
while (1) {
int gotExpectedTag;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_Component, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_Component, &gotExpectedTag))
return error;
if (!gotExpectedTag)
@@ -45,7 +45,7 @@
unsigned char *component;
unsigned int componentLen;
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement(decoder, ndn_BinaryXML_DTag_Component, 0, &component, &componentLen))
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(decoder, ndn_BinaryXml_DTag_Component, 0, &component, &componentLen))
return error;
// Add the component to the name.
@@ -55,7 +55,7 @@
++name->nComponents;
}
- if (error = ndn_BinaryXMLDecoder_readElementClose(decoder))
+ if (error = ndn_BinaryXmlDecoder_readElementClose(decoder))
return error;
return 0;
diff --git a/ndn-cpp/c/encoding/BinaryXMLName.h b/ndn-cpp/c/encoding/BinaryXMLName.h
index 0dee306..f165c4b 100644
--- a/ndn-cpp/c/encoding/BinaryXMLName.h
+++ b/ndn-cpp/c/encoding/BinaryXMLName.h
@@ -15,9 +15,9 @@
extern "C" {
#endif
-ndn_Error ndn_encodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlEncoder *encoder);
-ndn_Error ndn_decodeBinaryXMLName(struct ndn_Name *name, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlName(struct ndn_Name *name, struct ndn_BinaryXmlDecoder *decoder);
#ifdef __cplusplus
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c
index 00e3582..8a1fe63 100644
--- a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c
+++ b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.c
@@ -7,42 +7,42 @@
#include "BinaryXML.h"
#include "BinaryXMLPublisherPublicKeyDigest.h"
-ndn_Error ndn_encodeBinaryXMLPublisherPublicKeyDigest
- (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLEncoder *encoder)
+ndn_Error ndn_encodeBinaryXmlPublisherPublicKeyDigest
+ (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlEncoder *encoder)
{
if (!publisherPublicKeyDigest->publisherPublicKeyDigest || publisherPublicKeyDigest->publisherPublicKeyDigestLength == 0)
return;
ndn_Error error;
- if (error = ndn_BinaryXMLEncoder_writeBlobDTagElement
- (encoder, ndn_BinaryXML_DTag_PublisherPublicKeyDigest, publisherPublicKeyDigest->publisherPublicKeyDigest,
+ if (error = ndn_BinaryXmlEncoder_writeBlobDTagElement
+ (encoder, ndn_BinaryXml_DTag_PublisherPublicKeyDigest, publisherPublicKeyDigest->publisherPublicKeyDigest,
publisherPublicKeyDigest->publisherPublicKeyDigestLength))
return error;
return 0;
}
-ndn_Error ndn_decodeBinaryXMLPublisherPublicKeyDigest
- (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeBinaryXmlPublisherPublicKeyDigest
+ (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder)
{
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_readBinaryDTagElement
- (decoder, ndn_BinaryXML_DTag_PublisherPublicKeyDigest, 0, &publisherPublicKeyDigest->publisherPublicKeyDigest,
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (decoder, ndn_BinaryXml_DTag_PublisherPublicKeyDigest, 0, &publisherPublicKeyDigest->publisherPublicKeyDigest,
&publisherPublicKeyDigest->publisherPublicKeyDigestLength))
return error;
return 0;
}
-ndn_Error ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest
- (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder)
+ndn_Error ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest
+ (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder)
{
int gotExpectedTag;
ndn_Error error;
- if (error = ndn_BinaryXMLDecoder_peekDTag(decoder, ndn_BinaryXML_DTag_PublisherPublicKeyDigest, &gotExpectedTag))
+ if (error = ndn_BinaryXmlDecoder_peekDTag(decoder, ndn_BinaryXml_DTag_PublisherPublicKeyDigest, &gotExpectedTag))
return error;
if (gotExpectedTag) {
- if (error = ndn_decodeBinaryXMLPublisherPublicKeyDigest(publisherPublicKeyDigest, decoder))
+ if (error = ndn_decodeBinaryXmlPublisherPublicKeyDigest(publisherPublicKeyDigest, decoder))
return error;
}
else {
diff --git a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h
index 178a767..eb3e2a8 100644
--- a/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h
+++ b/ndn-cpp/c/encoding/BinaryXMLPublisherPublicKeyDigest.h
@@ -19,30 +19,30 @@
* Encode the ndn_PublisherPublicKeyDigest struct using Binary XML. If publisherPublicKeyDigest->publisherPublicKeyDigest or
* publisherPublicKeyDigestLength is 0, then do nothing.
* @param publisherPublicKeyDigest pointer to the ndn_PublisherPublicKeyDigest struct
- * @param encoder pointer to the ndn_BinaryXMLEncoder struct
+ * @param encoder pointer to the ndn_BinaryXmlEncoder struct
* @return 0 for success, else an error code
*/
-ndn_Error ndn_encodeBinaryXMLPublisherPublicKeyDigest
- (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLEncoder *encoder);
+ndn_Error ndn_encodeBinaryXmlPublisherPublicKeyDigest
+ (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlEncoder *encoder);
/**
* Expect the next element to be a Binary XML PublisherPublicKeyDigest and decode into the ndn_PublisherPublicKeyDigest struct.
* @param publisherPublicKeyDigest pointer to the ndn_PublisherPublicKeyDigest struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
* @return 0 for success, else an error code, including if the next element is not PublisherPublicKeyDigest.
*/
-ndn_Error ndn_decodeBinaryXMLPublisherPublicKeyDigest
- (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeBinaryXmlPublisherPublicKeyDigest
+ (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder);
/**
* Peek the next element and if it is a Binary XML PublisherPublicKeyDigest and decode into the ndn_PublisherPublicKeyDigest struct.
* Otherwise, set the ndn_PublisherPublicKeyDigest struct to none.
* @param publisherPublicKeyDigest pointer to the ndn_PublisherPublicKeyDigest struct
- * @param decoder pointer to the ndn_BinaryXMLDecoder struct
+ * @param decoder pointer to the ndn_BinaryXmlDecoder struct
* @return 0 for success, else an error code, including if the next element is not PublisherPublicKeyDigest.
*/
-ndn_Error ndn_decodeOptionalBinaryXMLPublisherPublicKeyDigest
- (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXMLDecoder *decoder);
+ndn_Error ndn_decodeOptionalBinaryXmlPublisherPublicKeyDigest
+ (struct ndn_PublisherPublicKeyDigest *publisherPublicKeyDigest, struct ndn_BinaryXmlDecoder *decoder);
#ifdef __cplusplus
}
diff --git a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c
index f9d7dda..dbd4ac5 100644
--- a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c
+++ b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.c
@@ -8,12 +8,12 @@
#include "BinaryXMLDecoder.h"
#include "BinaryXMLStructureDecoder.h"
-void ndn_BinaryXMLStructureDecoder_init(struct ndn_BinaryXMLStructureDecoder *self)
+void ndn_BinaryXmlStructureDecoder_init(struct ndn_BinaryXmlStructureDecoder *self)
{
self->gotElementEnd = 0;
self->offset = 0;
self->level = 0;
- self->state = ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE;
+ self->state = ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE;
self->headerLength = 0;
self->useHeaderBuffer = 0;
self->nBytesToRead = 0;
@@ -22,31 +22,31 @@
/**
* Set the state to READ_HEADER_OR_CLOSE and set up to start reading the header.
*/
-static inline void startHeader(struct ndn_BinaryXMLStructureDecoder *self)
+static inline void startHeader(struct ndn_BinaryXmlStructureDecoder *self)
{
self->headerLength = 0;
self->useHeaderBuffer = 0;
- self->state = ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE;
+ self->state = ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE;
}
-ndn_Error ndn_BinaryXMLStructureDecoder_findElementEnd
- (struct ndn_BinaryXMLStructureDecoder *self, unsigned char *input, unsigned int inputLength)
+ndn_Error ndn_BinaryXmlStructureDecoder_findElementEnd
+ (struct ndn_BinaryXmlStructureDecoder *self, unsigned char *input, unsigned int inputLength)
{
if (self->gotElementEnd)
// Someone is calling when we already got the end.
return 0;
- struct ndn_BinaryXMLDecoder decoder;
- ndn_BinaryXMLDecoder_init(&decoder, input, inputLength);
+ struct ndn_BinaryXmlDecoder decoder;
+ ndn_BinaryXmlDecoder_init(&decoder, input, inputLength);
while (1) {
if (self->offset >= inputLength)
// All the cases assume we have some input. Return and wait for more.
return 0;
- if (self->state == ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE) {
+ if (self->state == ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE) {
// First check for CLOSE.
- if (self->headerLength == 0 && input[self->offset] == ndn_BinaryXML_CLOSE) {
+ if (self->headerLength == 0 && input[self->offset] == ndn_BinaryXml_CLOSE) {
++self->offset;
// Close the level.
--self->level;
@@ -77,7 +77,7 @@
}
unsigned int headerByte = (unsigned int)input[self->offset++];
++self->headerLength;
- if (headerByte & ndn_BinaryXML_TT_FINAL)
+ if (headerByte & ndn_BinaryXml_TT_FINAL)
// Break and read the header.
break;
}
@@ -92,45 +92,45 @@
ndn_memcpy(self->headerBuffer + startingHeaderLength, input + (self->offset - nNewBytes), nNewBytes);
// Use a local decoder just for the headerBuffer.
- struct ndn_BinaryXMLDecoder bufferDecoder;
- ndn_BinaryXMLDecoder_init(&bufferDecoder, self->headerBuffer, sizeof(self->headerBuffer));
- if (ndn_BinaryXMLDecoder_decodeTypeAndValue(&bufferDecoder, &type, &value))
+ struct ndn_BinaryXmlDecoder bufferDecoder;
+ ndn_BinaryXmlDecoder_init(&bufferDecoder, self->headerBuffer, sizeof(self->headerBuffer));
+ if (ndn_BinaryXmlDecoder_decodeTypeAndValue(&bufferDecoder, &type, &value))
return NDN_ERROR_findElementEnd_cannot_read_header_type_and_value;
}
else {
// We didn't have to use the headerBuffer.
- ndn_BinaryXMLDecoder_seek(&decoder, self->offset - self->headerLength);
- if (ndn_BinaryXMLDecoder_decodeTypeAndValue(&decoder, &type, &value))
+ ndn_BinaryXmlDecoder_seek(&decoder, self->offset - self->headerLength);
+ if (ndn_BinaryXmlDecoder_decodeTypeAndValue(&decoder, &type, &value))
return NDN_ERROR_findElementEnd_cannot_read_header_type_and_value;
}
// Set the next state based on the type.
- if (type == ndn_BinaryXML_DATTR)
+ if (type == ndn_BinaryXml_DATTR)
// We already consumed the item. READ_HEADER_OR_CLOSE again.
// Binary XML has rules about what must follow an attribute, but we are just scanning.
startHeader(self);
- else if (type == ndn_BinaryXML_DTAG || type == ndn_BinaryXML_EXT) {
+ else if (type == ndn_BinaryXml_DTAG || type == ndn_BinaryXml_EXT) {
// Start a new level and READ_HEADER_OR_CLOSE again.
++self->level;
startHeader(self);
}
- else if (type == ndn_BinaryXML_TAG || type == ndn_BinaryXML_ATTR) {
- if (type == ndn_BinaryXML_TAG)
+ else if (type == ndn_BinaryXml_TAG || type == ndn_BinaryXml_ATTR) {
+ if (type == ndn_BinaryXml_TAG)
// Start a new level and read the tag.
++self->level;
// Minimum tag or attribute length is 1.
self->nBytesToRead = value + 1;
- self->state = ndn_BinaryXMLStructureDecoder_READ_BYTES;
+ self->state = ndn_BinaryXmlStructureDecoder_READ_BYTES;
// Binary XML has rules about what must follow an attribute, but we are just scanning.
}
- else if (type == ndn_BinaryXML_BLOB || type == ndn_BinaryXML_UDATA) {
+ else if (type == ndn_BinaryXml_BLOB || type == ndn_BinaryXml_UDATA) {
self->nBytesToRead = value;
- self->state = ndn_BinaryXMLStructureDecoder_READ_BYTES;
+ self->state = ndn_BinaryXmlStructureDecoder_READ_BYTES;
}
else
return NDN_ERROR_findElementEnd_unrecognized_header_type;
}
- else if (self->state == ndn_BinaryXMLStructureDecoder_READ_BYTES) {
+ else if (self->state == ndn_BinaryXmlStructureDecoder_READ_BYTES) {
unsigned int nRemainingBytes = inputLength - self->offset;
if (nRemainingBytes < self->nBytesToRead) {
// Need more.
diff --git a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h
index 603ee43..8c561a1 100644
--- a/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h
+++ b/ndn-cpp/c/encoding/BinaryXMLStructureDecoder.h
@@ -12,7 +12,7 @@
extern "C" {
#endif
-struct ndn_BinaryXMLStructureDecoder {
+struct ndn_BinaryXmlStructureDecoder {
int gotElementEnd; /**< boolean */
unsigned int offset;
int level;
@@ -25,31 +25,31 @@
};
enum {
- ndn_BinaryXMLStructureDecoder_READ_HEADER_OR_CLOSE,
- ndn_BinaryXMLStructureDecoder_READ_BYTES
+ ndn_BinaryXmlStructureDecoder_READ_HEADER_OR_CLOSE,
+ ndn_BinaryXmlStructureDecoder_READ_BYTES
};
-void ndn_BinaryXMLStructureDecoder_init(struct ndn_BinaryXMLStructureDecoder *self);
+void ndn_BinaryXmlStructureDecoder_init(struct ndn_BinaryXmlStructureDecoder *self);
/**
* Continue scanning input starting from self->offset to find the element end. On return, you must check
* self->gotElementEnd: If the end of the element which started at offset 0 is found,
* then self->gotElementEnd is 1 and self->offset is the length of the element. Otherwise, self-forElementEnd is 0
* which means you should read more into input and call again.
- * @param self pointer to the ndn_BinaryXMLStructureDecoder struct
+ * @param self pointer to the ndn_BinaryXmlStructureDecoder struct
* @param input the input buffer. You have to pass in input each time because the buffer could be reallocated.
* @param inputLength the number of bytes in input.
* @return 0 for success, else an error code
*/
-ndn_Error ndn_BinaryXMLStructureDecoder_findElementEnd
- (struct ndn_BinaryXMLStructureDecoder *self, unsigned char *input, unsigned int inputLength);
+ndn_Error ndn_BinaryXmlStructureDecoder_findElementEnd
+ (struct ndn_BinaryXmlStructureDecoder *self, unsigned char *input, unsigned int inputLength);
/**
* Set the offset into the input, used for the next read.
- * @param self pointer to the ndn_BinaryXMLStructureDecoder struct
+ * @param self pointer to the ndn_BinaryXmlStructureDecoder struct
* @param offset the new offset
*/
-static inline void ndn_BinaryXMLStructureDecoder_seek(struct ndn_BinaryXMLStructureDecoder *self, unsigned int offset)
+static inline void ndn_BinaryXmlStructureDecoder_seek(struct ndn_BinaryXmlStructureDecoder *self, unsigned int offset)
{
self->offset = offset;
}