proxygen::StructuredHeaders Namespace Reference

Classes
struct	ParameterisedIdentifier
class	StructuredHeaderItem
class	StructuredHeadersUtilitiesTest

Typedefs
using	ParameterisedList = std::vector< StructuredHeaders::ParameterisedIdentifier >
using	Dictionary = std::unordered_map< std::string, StructuredHeaderItem >

Enumerations
enum	DecodeError : uint8_t {   DecodeError::OK = 0, DecodeError::VALUE_TOO_LONG = 1, DecodeError::INVALID_CHARACTER = 2, DecodeError::UNDECODEABLE_BINARY_CONTENT = 3,   DecodeError::UNEXPECTED_END_OF_BUFFER = 4, DecodeError::UNPARSEABLE_NUMERIC_TYPE = 5, DecodeError::DUPLICATE_KEY = 6 }
enum	EncodeError : uint8_t {   EncodeError::OK = 0, EncodeError::EMPTY_DATA_STRUCTURE = 1, EncodeError::BAD_IDENTIFIER = 2, EncodeError::BAD_STRING = 3,   EncodeError::ITEM_TYPE_MISMATCH = 4, EncodeError::ENCODING_NULL_ITEM = 5 }

Functions
bool	isLcAlpha (char c)
bool	isValidIdentifierChar (char c)
bool	isValidEncodedBinaryContentChar (char c)
bool	isValidStringChar (char c)
bool	isValidIdentifier (const std::string &s)
bool	isValidString (const std::string &s)
bool	isValidEncodedBinaryContent (const std::string &s)
bool	itemTypeMatchesContent (const StructuredHeaderItem &input)
std::string	decodeBase64 (const std::string &encoded)
std::string	encodeBase64 (const std::string &input)
	TEST_F (StructuredHeadersUtilitiesTest, TestLcalpha)
	TEST_F (StructuredHeadersUtilitiesTest, TestIsValidIdentifierChar)
	TEST_F (StructuredHeadersUtilitiesTest, test_isValidEncodedBinaryContentChar_alphanumeric)
	TEST_F (StructuredHeadersUtilitiesTest, test_isValidEncodedBinaryContentChar_allowed_symbols)
	TEST_F (StructuredHeadersUtilitiesTest, test_isValidEncodedBinaryContentChar_disallowed_symbols)
	TEST_F (StructuredHeadersUtilitiesTest, TestIsValidStringCharAllowed)
	TEST_F (StructuredHeadersUtilitiesTest, TestIsValidStringCharDisallowed)
	TEST_F (StructuredHeadersUtilitiesTest, TestIsValidIdentifierAllowed)
	TEST_F (StructuredHeadersUtilitiesTest, TestIsValidIdentifierDisallowed)
	TEST_F (StructuredHeadersUtilitiesTest, TestIsValidStringAllowed)
	TEST_F (StructuredHeadersUtilitiesTest, TestIsValidStringDisallowed)
	TEST_F (StructuredHeadersUtilitiesTest, TestGoodBinaryContent)
	TEST_F (StructuredHeadersUtilitiesTest, TestBadBinaryContent)
	TEST_F (StructuredHeadersUtilitiesTest, Test_DecodeBinaryContent)
	TEST_F (StructuredHeadersUtilitiesTest, Test_EncodeBinaryContent)
	TEST_F (StructuredHeadersUtilitiesTest, Test_BinaryContentEmpty)
	TEST_F (StructuredHeadersUtilitiesTest, TestItemTypeMatchesContentGood)
	TEST_F (StructuredHeadersUtilitiesTest, TestItemTypeMatchesContentBad)

Variables
static const int	kMaxValidIntegerLength = 19
static const int	kMaxValidFloatLength = 16
static const std::map< DecodeError, std::string >	decodeErrorDescription
static const std::map< EncodeError, std::string >	encodeErrorDescription

Typedef Documentation

using proxygen::StructuredHeaders::Dictionary = typedef std::unordered_map<std::string, StructuredHeaderItem>

Definition at line 61 of file StructuredHeadersConstants.h.

using proxygen::StructuredHeaders::ParameterisedList = typedef std::vector<StructuredHeaders::ParameterisedIdentifier>

Definition at line 59 of file StructuredHeadersConstants.h.

Enumeration Type Documentation

enum proxygen::StructuredHeaders::DecodeError : uint8_t

strong

Enumerator
OK
VALUE_TOO_LONG
INVALID_CHARACTER
UNDECODEABLE_BINARY_CONTENT
UNEXPECTED_END_OF_BUFFER
UNPARSEABLE_NUMERIC_TYPE
DUPLICATE_KEY

Definition at line 63 of file StructuredHeadersConstants.h.

                       : uint8_t {
  OK = 0,
  VALUE_TOO_LONG = 1,
  INVALID_CHARACTER = 2,
  UNDECODEABLE_BINARY_CONTENT = 3,
  UNEXPECTED_END_OF_BUFFER = 4,
  UNPARSEABLE_NUMERIC_TYPE = 5,
  DUPLICATE_KEY = 6
};

enum proxygen::StructuredHeaders::EncodeError : uint8_t

strong

Enumerator
OK
EMPTY_DATA_STRUCTURE
BAD_IDENTIFIER
BAD_STRING
ITEM_TYPE_MISMATCH
ENCODING_NULL_ITEM

Definition at line 73 of file StructuredHeadersConstants.h.

                       : uint8_t {
  OK = 0,
  EMPTY_DATA_STRUCTURE = 1,
  BAD_IDENTIFIER = 2,
  BAD_STRING = 3,
  ITEM_TYPE_MISMATCH = 4,
  ENCODING_NULL_ITEM = 5
};

Function Documentation

std::string proxygen::StructuredHeaders::decodeBase64

(

const std::string &

encoded

)

Definition at line 105 of file StructuredHeadersUtilities.cpp.

References folly::test::begin(), count, folly::test::end(), string, and uint32_t.

Referenced by proxygen::StructuredHeadersBuffer::parseBinaryContent(), and TEST_F().

                              {

  if (encoded.size() == 0) {
    // special case, to prevent an integer overflow down below.
    return "";
  }

  using namespace boost::archive::iterators;
  using b64it =
    transform_width<binary_from_base64<std::string::const_iterator>, 8, 6>;

  std::string decoded = std::string(b64it(std::begin(encoded)),
                                    b64it(std::end(encoded)));

  uint32_t numPadding = std::count(encoded.begin(), encoded.end(), '=');
  decoded.erase(decoded.end() - numPadding, decoded.end());

  return decoded;
}

std::string proxygen::StructuredHeaders::encodeBase64

(

const std::string &

input

)

Definition at line 126 of file StructuredHeadersUtilities.cpp.

References data, and string.

Referenced by proxygen::StructuredHeadersEncoder::encodeBinaryContent(), proxygen::StructuredHeadersBuffer::parseBinaryContent(), and TEST_F().

                                               {
  using namespace boost::archive::iterators;
  using b64it = base64_from_binary<transform_width<const char*, 6, 8>>;

  auto data = input.data();
  std::string encoded(b64it(data), b64it(data + (input.length())));
  encoded.append((3 - (input.length() % 3)) % 3, '=');

  return encoded;
}

bool proxygen::StructuredHeaders::isLcAlpha

(

char

c

)

Definition at line 20 of file StructuredHeadersUtilities.cpp.

Referenced by isValidIdentifier(), isValidIdentifierChar(), proxygen::StructuredHeadersBuffer::parseIdentifier(), and TEST_F().

                       {
  return c >= 0x61 && c <= 0x7A;
}

bool proxygen::StructuredHeaders::isValidEncodedBinaryContent

(

const std::string &

s

)

Definition at line 68 of file StructuredHeadersUtilities.cpp.

References isValidEncodedBinaryContentChar().

Referenced by proxygen::StructuredHeadersBuffer::parseBinaryContent(), and TEST_F().

                      {

  if (s.size() % 4 != 0) {
    return false;
  }

  bool equalSeen = false;
  for (auto it = s.begin(); it != s.end(); it++) {
    if (*it == '=') {
      equalSeen = true;
    } else if (equalSeen || !isValidEncodedBinaryContentChar(*it)) {
      return false;
    }
  }

  return true;
}

bool proxygen::StructuredHeaders::isValidEncodedBinaryContentChar

(

char

c

)

Definition at line 29 of file StructuredHeadersUtilities.cpp.

Referenced by isValidEncodedBinaryContent(), proxygen::StructuredHeadersBuffer::parseBinaryContent(), and TEST_F().

           {
  return std::isalpha(c) || std::isdigit(c) || c == '+' || c == '/' || c == '=';
}

bool proxygen::StructuredHeaders::isValidIdentifier

(

const std::string &

s

)

Definition at line 45 of file StructuredHeadersUtilities.cpp.

References c, isLcAlpha(), and isValidIdentifierChar().

Referenced by proxygen::StructuredHeadersEncoder::encodeIdentifier(), and TEST_F().

                                           {
  if (s.size() == 0 || !isLcAlpha(s[0])) {
    return false;
  }

  for (char c : s) {
    if (!isValidIdentifierChar(c)) {
      return false;
    }
  }

  return true;
}

bool proxygen::StructuredHeaders::isValidIdentifierChar

(

char

c

)

Definition at line 24 of file StructuredHeadersUtilities.cpp.

References isLcAlpha().

Referenced by isValidIdentifier(), proxygen::StructuredHeadersBuffer::parseIdentifier(), and TEST_F().

                                   {
  return isLcAlpha(c) || std::isdigit(c) || c == '_' || c == '-' || c == '*' ||
    c == '/';
}

bool proxygen::StructuredHeaders::isValidString

(

const std::string &

s

)

Definition at line 59 of file StructuredHeadersUtilities.cpp.

References c, and isValidStringChar().

Referenced by proxygen::StructuredHeadersEncoder::encodeString(), and TEST_F().

                                       {
  for (char c : s) {
    if (!isValidStringChar(c)) {
      return false;
    }
  }
  return true;
}

bool proxygen::StructuredHeaders::isValidStringChar

(

char

c

)

Definition at line 34 of file StructuredHeadersUtilities.cpp.

Referenced by isValidString(), proxygen::StructuredHeadersBuffer::parseString(), and TEST_F().

                               {
  /*
  * The difference between the character restriction here and that mentioned
  * in section 3.7 of version 6 of the Structured Headers draft is that this
  * function accepts \ and DQUOTE characters. These characters are allowed
  * as long as they are present as a part of an escape sequence, which is
  * checked for in the parseString() function in the StructuredHeadersBuffer.
  */
  return c >= 0x20 && c <= 0x7E;
}

bool proxygen::StructuredHeaders::itemTypeMatchesContent

(

const StructuredHeaderItem &

input

)

Definition at line 87 of file StructuredHeadersUtilities.cpp.

References proxygen::StructuredHeaders::StructuredHeaderItem::BINARYCONTENT, proxygen::StructuredHeaders::StructuredHeaderItem::DOUBLE, proxygen::StructuredHeaders::StructuredHeaderItem::IDENTIFIER, proxygen::StructuredHeaders::StructuredHeaderItem::INT64, int64_t, proxygen::StructuredHeaders::StructuredHeaderItem::NONE, proxygen::StructuredHeaders::StructuredHeaderItem::STRING, string, proxygen::StructuredHeaders::StructuredHeaderItem::tag, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

Referenced by proxygen::StructuredHeadersEncoder::encodeItem(), and TEST_F().

                                      {
  switch (input.tag) {
    case StructuredHeaderItem::Type::BINARYCONTENT:
    case StructuredHeaderItem::Type::IDENTIFIER:
    case StructuredHeaderItem::Type::STRING:
      return input.value.type() == typeid(std::string);
    case StructuredHeaderItem::Type::INT64:
      return input.value.type() == typeid(int64_t);
    case StructuredHeaderItem::Type::DOUBLE:
      return input.value.type() == typeid(double);
    case StructuredHeaderItem::Type::NONE:
      return true;
  }

  return false;
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestLcalpha
	)

Definition at line 20 of file StructuredHeadersUtilitiesTest.cpp.

References c, EXPECT_FALSE, EXPECT_TRUE, i, isLcAlpha(), uint32_t, and uint8_t.

                                                    {
  for (uint32_t i = 0; i < 256; i++) {
    uint8_t c = (uint8_t) i;
    if (c >= 'a' && c <= 'z') {
      EXPECT_TRUE(isLcAlpha(c));
    } else {
      EXPECT_FALSE(isLcAlpha(c));
    }
  }
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestIsValidIdentifierChar
	)

Definition at line 31 of file StructuredHeadersUtilitiesTest.cpp.

References c, EXPECT_FALSE, EXPECT_TRUE, i, isValidIdentifierChar(), uint32_t, and uint8_t.

                                                                  {
  for (uint32_t i = 0; i < 256; i++) {
    uint8_t c = (uint8_t) i;
    if ((c >= 'a' && c <= 'z') ||
        (c >= '0' && c <= '9') ||
        (c == '_' || c == '-' || c == '*' || c == '/')) {
      EXPECT_TRUE(isValidIdentifierChar(c));
    } else {
      EXPECT_FALSE(isValidIdentifierChar(c));
    }
  }
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		test_isValidEncodedBinaryContentChar_alphanumeric
	)

Definition at line 44 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_TRUE, and isValidEncodedBinaryContentChar().

                                                      {
  EXPECT_TRUE(isValidEncodedBinaryContentChar('a'));
  EXPECT_TRUE(isValidEncodedBinaryContentChar('Z'));
  EXPECT_TRUE(isValidEncodedBinaryContentChar('0'));
  EXPECT_TRUE(isValidEncodedBinaryContentChar('9'));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		test_isValidEncodedBinaryContentChar_allowed_symbols
	)

Definition at line 52 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_TRUE, and isValidEncodedBinaryContentChar().

                                                         {
  EXPECT_TRUE(isValidEncodedBinaryContentChar('+'));
  EXPECT_TRUE(isValidEncodedBinaryContentChar('/'));
  EXPECT_TRUE(isValidEncodedBinaryContentChar('='));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		test_isValidEncodedBinaryContentChar_disallowed_symbols
	)

Definition at line 59 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_FALSE, and isValidEncodedBinaryContentChar().

                                                            {
  EXPECT_FALSE(isValidEncodedBinaryContentChar('*'));
  EXPECT_FALSE(isValidEncodedBinaryContentChar('_'));
  EXPECT_FALSE(isValidEncodedBinaryContentChar('-'));
  EXPECT_FALSE(isValidEncodedBinaryContentChar(' '));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestIsValidStringCharAllowed
	)

Definition at line 67 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_TRUE, and isValidStringChar().

                                                                     {
  EXPECT_TRUE(isValidStringChar(' '));
  EXPECT_TRUE(isValidStringChar('~'));
  EXPECT_TRUE(isValidStringChar('\\'));
  EXPECT_TRUE(isValidStringChar('\"'));
  EXPECT_TRUE(isValidStringChar('a'));
  EXPECT_TRUE(isValidStringChar('0'));
  EXPECT_TRUE(isValidStringChar('A'));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestIsValidStringCharDisallowed
	)

Definition at line 77 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_FALSE, and isValidStringChar().

                                                                        {
  EXPECT_FALSE(isValidStringChar('\0'));
  EXPECT_FALSE(isValidStringChar(0x1F));
  EXPECT_FALSE(isValidStringChar(0x7F));
  EXPECT_FALSE(isValidStringChar('\t'));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestIsValidIdentifierAllowed
	)

Definition at line 84 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_TRUE, and isValidIdentifier().

                                                                     {
  EXPECT_TRUE(isValidIdentifier("a"));
  EXPECT_TRUE(isValidIdentifier("a_0-*/"));
  EXPECT_TRUE(isValidIdentifier("abc___xyz"));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestIsValidIdentifierDisallowed
	)

Definition at line 90 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_FALSE, and isValidIdentifier().

                                                                        {
  EXPECT_FALSE(isValidIdentifier("aAAA"));
  EXPECT_FALSE(isValidIdentifier("_aa"));
  EXPECT_FALSE(isValidIdentifier("0abc"));
  EXPECT_FALSE(isValidIdentifier(""));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestIsValidStringAllowed
	)

Definition at line 97 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_TRUE, and isValidString().

                                                                 {
  EXPECT_TRUE(isValidString("a cat."));
  EXPECT_TRUE(isValidString("!~)($@^^) g"));
  EXPECT_TRUE(isValidString("\\\"\"\\"));
  EXPECT_TRUE(isValidString(""));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestIsValidStringDisallowed
	)

Definition at line 104 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_FALSE, and isValidString().

                                                                    {
  EXPECT_FALSE(isValidString("a\tcat."));
  EXPECT_FALSE(isValidString("\x10 aaaaaaa"));
  EXPECT_FALSE(isValidString("chocolate\x11"));
  EXPECT_FALSE(isValidString("pota\nto"));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestGoodBinaryContent
	)

Definition at line 111 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_TRUE, and isValidEncodedBinaryContent().

                                                              {
  EXPECT_TRUE(isValidEncodedBinaryContent("aGVsbG8="));
  EXPECT_TRUE(isValidEncodedBinaryContent("ZGZzZGZmc2Rm"));
  EXPECT_TRUE(isValidEncodedBinaryContent("ZA=="));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestBadBinaryContent
	)

Definition at line 117 of file StructuredHeadersUtilitiesTest.cpp.

References EXPECT_FALSE, and isValidEncodedBinaryContent().

                                                             {
  EXPECT_FALSE(isValidEncodedBinaryContent("aGVsbG8"));
  EXPECT_FALSE(isValidEncodedBinaryContent("aGVsb G8="));
  EXPECT_FALSE(isValidEncodedBinaryContent("aGVsbG!8="));
  EXPECT_FALSE(isValidEncodedBinaryContent("=aGVsbG8"));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		Test_DecodeBinaryContent
	)

Definition at line 124 of file StructuredHeadersUtilitiesTest.cpp.

References decodeBase64(), EXPECT_EQ, and string.

                                                                 {
  std::string input1 = "ZnJ1aXQ=";
  std::string input2 = "dG9tYXRv";
  std::string input3 = "ZWdncw==";
  EXPECT_EQ(decodeBase64(input1), "fruit");
  EXPECT_EQ(decodeBase64(input2), "tomato");
  EXPECT_EQ(decodeBase64(input3), "eggs");
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		Test_EncodeBinaryContent
	)

Definition at line 133 of file StructuredHeadersUtilitiesTest.cpp.

References encodeBase64(), EXPECT_EQ, and string.

                                                                 {
  std::string input1 = "fruit";
  std::string input2 = "tomato";
  std::string input3 = "eggs";
  EXPECT_EQ(encodeBase64(input1), "ZnJ1aXQ=");
  EXPECT_EQ(encodeBase64(input2), "dG9tYXRv");
  EXPECT_EQ(encodeBase64(input3), "ZWdncw==");
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		Test_BinaryContentEmpty
	)

Definition at line 142 of file StructuredHeadersUtilitiesTest.cpp.

References decodeBase64(), encodeBase64(), EXPECT_EQ, and string.

                                                                {
  std::string input1 = "";
  std::string input2 = "";
  EXPECT_EQ(encodeBase64(input1), "");
  EXPECT_EQ(decodeBase64(input2), "");
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestItemTypeMatchesContentGood
	)

Definition at line 149 of file StructuredHeadersUtilitiesTest.cpp.

References proxygen::StructuredHeaders::StructuredHeaderItem::BINARYCONTENT, proxygen::StructuredHeaders::StructuredHeaderItem::DOUBLE, EXPECT_TRUE, proxygen::StructuredHeaders::StructuredHeaderItem::IDENTIFIER, proxygen::StructuredHeaders::StructuredHeaderItem::INT64, int64_t, itemTypeMatchesContent(), proxygen::StructuredHeaders::StructuredHeaderItem::NONE, proxygen::StructuredHeaders::StructuredHeaderItem::STRING, proxygen::StructuredHeaders::StructuredHeaderItem::tag, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

                                                                       {
  StructuredHeaderItem item;
  item.value = "\"potato\"";
  item.tag = StructuredHeaderItem::Type::STRING;
  EXPECT_TRUE(itemTypeMatchesContent(item));

  item.value = "a_800";
  item.tag = StructuredHeaderItem::Type::IDENTIFIER;
  EXPECT_TRUE(itemTypeMatchesContent(item));

  item.tag = StructuredHeaderItem::Type::NONE;
  EXPECT_TRUE(itemTypeMatchesContent(item));

  item.value = "hello";
  item.tag = StructuredHeaderItem::Type::BINARYCONTENT;
  EXPECT_TRUE(itemTypeMatchesContent(item));

  item.value = int64_t(88);
  item.tag = StructuredHeaderItem::Type::INT64;
  EXPECT_TRUE(itemTypeMatchesContent(item));

  item.value = double(88.8);
  item.tag = StructuredHeaderItem::Type::DOUBLE;
  EXPECT_TRUE(itemTypeMatchesContent(item));
}

proxygen::StructuredHeaders::TEST_F	(	StructuredHeadersUtilitiesTest	,
		TestItemTypeMatchesContentBad
	)

Definition at line 175 of file StructuredHeadersUtilitiesTest.cpp.

References proxygen::StructuredHeaders::StructuredHeaderItem::BINARYCONTENT, proxygen::StructuredHeaders::StructuredHeaderItem::DOUBLE, EXPECT_FALSE, proxygen::StructuredHeaders::StructuredHeaderItem::IDENTIFIER, proxygen::StructuredHeaders::StructuredHeaderItem::INT64, int64_t, itemTypeMatchesContent(), proxygen::StructuredHeaders::StructuredHeaderItem::STRING, proxygen::StructuredHeaders::StructuredHeaderItem::tag, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

                                                                      {
  StructuredHeaderItem item;

  item.value = "hello";
  item.tag = StructuredHeaderItem::Type::DOUBLE;
  EXPECT_FALSE(itemTypeMatchesContent(item));
  item.tag = StructuredHeaderItem::Type::INT64;
  EXPECT_FALSE(itemTypeMatchesContent(item));

  item.value = int64_t(68);
  item.tag = StructuredHeaderItem::Type::DOUBLE;
  EXPECT_FALSE(itemTypeMatchesContent(item));
  item.tag = StructuredHeaderItem::Type::STRING;
  EXPECT_FALSE(itemTypeMatchesContent(item));
  item.tag = StructuredHeaderItem::Type::BINARYCONTENT;
  EXPECT_FALSE(itemTypeMatchesContent(item));
  item.tag = StructuredHeaderItem::Type::IDENTIFIER;
  EXPECT_FALSE(itemTypeMatchesContent(item));

  item.value = double(68.8);
  item.tag = StructuredHeaderItem::Type::INT64;
  EXPECT_FALSE(itemTypeMatchesContent(item));
  item.tag = StructuredHeaderItem::Type::IDENTIFIER;
  EXPECT_FALSE(itemTypeMatchesContent(item));
  item.tag = StructuredHeaderItem::Type::STRING;
  EXPECT_FALSE(itemTypeMatchesContent(item));
  item.tag = StructuredHeaderItem::Type::BINARYCONTENT;
  EXPECT_FALSE(itemTypeMatchesContent(item));
}

Variable Documentation

const std::map<DecodeError, std::string> proxygen::StructuredHeaders::decodeErrorDescription

static

Initial value:

{
    {DecodeError::OK, "No error"},
    {DecodeError::VALUE_TOO_LONG, "Numeric value is too long"},
    {DecodeError::INVALID_CHARACTER, "Invalid character"},
    {DecodeError::UNDECODEABLE_BINARY_CONTENT, "Undecodable binary content"},
    {DecodeError::UNEXPECTED_END_OF_BUFFER, "Unexpected end of buffer"},
    {DecodeError::UNPARSEABLE_NUMERIC_TYPE, "Unparseable numeric type"},
    {DecodeError::DUPLICATE_KEY, "Duplicate key found"}
}

Definition at line 83 of file StructuredHeadersConstants.h.

Referenced by proxygen::StructuredHeadersBuffer::handleDecodeError().

const std::map<EncodeError, std::string> proxygen::StructuredHeaders::encodeErrorDescription

static

Initial value:

{
    {EncodeError::OK, "No error"},
    {EncodeError::EMPTY_DATA_STRUCTURE, "Empty data structure"},
    {EncodeError::BAD_IDENTIFIER, "Bad identifier"},
    {EncodeError::BAD_STRING, "Bad string"},
    {EncodeError::ITEM_TYPE_MISMATCH, "Item type mismatch"},
    {EncodeError::ENCODING_NULL_ITEM, "Tried to encode null item"}
}

Definition at line 94 of file StructuredHeadersConstants.h.

Referenced by proxygen::StructuredHeadersEncoder::handleEncodeError().

const int proxygen::StructuredHeaders::kMaxValidFloatLength = 16

static

Definition at line 21 of file StructuredHeadersConstants.h.

Referenced by proxygen::StructuredHeadersBuffer::parseNumber(), and proxygen::StructuredHeadersEncoder::StructuredHeadersEncoder().

const int proxygen::StructuredHeaders::kMaxValidIntegerLength = 19

static

Definition at line 20 of file StructuredHeadersConstants.h.

Referenced by proxygen::StructuredHeadersBuffer::parseNumber().