C++ CVariant::type方法代码示例

TEST(TestVariant, VariantTypeNull)
{
  CVariant a;

  EXPECT_TRUE(a.isNull());
  EXPECT_EQ(CVariant::VariantTypeNull, a.type());
}

bool CSmartPlaylist::Save(CVariant &obj, bool full /* = true */) const
{
  if (obj.type() == CVariant::VariantTypeConstNull)
    return false;

  obj.clear();
  // add "type", "name" and "match"
  obj["type"] = m_playlistType;
  obj["match"] = m_matchAllRules ? "all" : "one";

  if (full)
    obj["name"] = m_playlistName;

  // add "rules"
  obj["rules"] = CVariant(CVariant::VariantTypeArray);
  for (vector<CSmartPlaylistRule>::const_iterator it = m_playlistRules.begin(); it != m_playlistRules.end(); ++it)
    it->Save(obj["rules"]);

  // add "limit"
  if (full && m_limit)
    obj["limit"] = m_limit;

  // add "order"
  if (full && m_orderField != SortByNone)
  {
    obj["order"] = CVariant(CVariant::VariantTypeObject);
    obj["order"]["method"] = CSmartPlaylistRule::TranslateOrder(m_orderField);
    obj["order"]["direction"] = m_orderAscending ? "ascending" : "descending";
  }

  return true;
}

bool CJSONVariantWriter::InternalWrite(yajl_gen g, const CVariant &value)
{
  bool success = false;

  switch (value.type())
  {
  case CVariant::VariantTypeInteger:
    success = yajl_gen_status_ok == yajl_gen_integer(g, (long long int)value.asInteger());
    break;
  case CVariant::VariantTypeUnsignedInteger:
    success = yajl_gen_status_ok == yajl_gen_integer(g, (long long int)value.asUnsignedInteger());
    break;
  case CVariant::VariantTypeDouble:
    success = yajl_gen_status_ok == yajl_gen_double(g, value.asDouble());
    break;
  case CVariant::VariantTypeBoolean:
    success = yajl_gen_status_ok == yajl_gen_bool(g, value.asBoolean() ? 1 : 0);
    break;
  case CVariant::VariantTypeString:
    success = yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)value.c_str(), (size_t)value.size());
    break;
  case CVariant::VariantTypeArray:
    success = yajl_gen_status_ok == yajl_gen_array_open(g);

    for (CVariant::const_iterator_array itr = value.begin_array(); itr != value.end_array() && success; ++itr)
      success &= InternalWrite(g, *itr);

    if (success)
      success = yajl_gen_status_ok == yajl_gen_array_close(g);

    break;
  case CVariant::VariantTypeObject:
    success = yajl_gen_status_ok == yajl_gen_map_open(g);

    for (CVariant::const_iterator_map itr = value.begin_map(); itr != value.end_map() && success; ++itr)
    {
      success &= yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)itr->first.c_str(), (size_t)itr->first.length());
      if (success)
        success &= InternalWrite(g, itr->second);
    }

    if (success)
      success &= yajl_gen_status_ok == yajl_gen_map_close(g);

    break;
  case CVariant::VariantTypeConstNull:
  case CVariant::VariantTypeNull:
  default:
    success = yajl_gen_status_ok == yajl_gen_null(g);
    break;
  }

  return success;
}

TEST(TestVariant, VariantFromMap)
{
  std::map<std::string, std::string> strMap;
  strMap["key"] = "value";
  CVariant a = strMap;
  
  EXPECT_TRUE(a.isObject());
  EXPECT_TRUE(a.size() == 1);
  EXPECT_EQ(CVariant::VariantTypeObject, a.type());
  EXPECT_TRUE(a.isMember("key"));
  EXPECT_TRUE(a["key"].isString());
  EXPECT_STREQ(a["key"].asString().c_str(), "value");
  
  std::map<std::string, CVariant> variantMap;
  variantMap["key"] = CVariant("value");
  CVariant b = variantMap;
  
  EXPECT_TRUE(b.isObject());
  EXPECT_TRUE(b.size() == 1);
  EXPECT_EQ(CVariant::VariantTypeObject, b.type());
  EXPECT_TRUE(b.isMember("key"));
  EXPECT_TRUE(b["key"].isString());
  EXPECT_STREQ(b["key"].asString().c_str(), "value");
}

bool CFileUtil::writeVariant(IFileObject* file, const CVariant& value)
{
	EVariantType type = value.type();
	if ( !file->write(&type, sizeof(uint8)) ) return false;

	switch(type)
	{
		case VT_NONE:
		break;
		case VT_BOOLEAN:
			{
				bool writebool;
				if ( !value.get(writebool) || !file->write(&writebool, sizeof(bool)) ) return false;
			}
		break;
		case VT_UINT:
			{
				uint64 writeuint;
				if ( !value.get(writeuint) || !file->write(&writeuint, sizeof(uint64)) ) return false;
			}
		break;
		case VT_INT:
			{
				int64 writeint;
				if ( !value.get(writeint) || !file->write(&writeint, sizeof(int64)) ) return false;
			}
		break;
		case VT_DOUBLE:
			{
				double writedouble;
				if ( !value.get(writedouble) || !file->write(&writedouble, sizeof(double)) ) return false;
			}
		break;
		case VT_STRING:
			{
				CString writestr;
				if ( !value.get(writestr) || !CFileUtil::writeString(file, writestr) ) return false;
			}
		break;
		default:
		return false;
	}

	return true;
}