//-----------------------------------------------------------------------------
int Profile::GetDoubleValues(const char* key, double* values, int num_vals) const
{
JSON* value = NULL;
if (ValMap.Get(key, &value) && value->Type == JSON_Array)
{
int val_count = Alg::Min(value->GetArraySize(), num_vals);
JSON* item = value->GetFirstItem();
int count=0;
while (item && count < val_count)
{
if (item->Type == JSON_Number)
values[count] = item->dValue;
else
break;
count++;
item = value->GetNextItem(item);
}
return count;
}
else
{
return 0;
}
}
//-----------------------------------------------------------------------------
int Profile::GetNumValues(const char* key) const
{
JSON* value = NULL;
if (ValMap.Get(key, &value))
{
if (value->Type == JSON_Array)
return value->GetArraySize();
else
return 1;
}
else
return 0;
}
static JSON* FindTaggedData(JSON* data, const char** tag_names, const char** qtags, int num_qtags)
{
if (data == NULL || !(data->Name == "TaggedData") || data->Type != JSON_Array)
return NULL;
JSON* tagged_item = data->GetFirstItem();
while (tagged_item)
{
JSON* tags = tagged_item->GetItemByName("tags");
if (tags->Type == JSON_Array && num_qtags == tags->GetArraySize())
{ // Check for a full tag match on each item
int num_matches = 0;
for (int k=0; k<num_qtags; k++)
{
JSON* tag = tags->GetFirstItem();
while (tag)
{
JSON* tagval = tag->GetFirstItem();
if (tagval && tagval->Name == tag_names[k])
{
if (tagval->Value == qtags[k])
num_matches++;
break;
}
tag = tags->GetNextItem(tag);
}
}
// if all tags were matched then copy the values into this Profile
if (num_matches == num_qtags)
{
JSON* vals = tagged_item->GetItemByName("vals");
return vals;
}
}
tagged_item = data->GetNextItem(tagged_item);
}
return NULL;
}
//-----------------------------------------------------------------------------
void Profile::SetDoubleValues(const char* key, const double* vals, int num_vals)
{
JSON* value = NULL;
int val_count = 0;
if (ValMap.Get(key, &value))
{
if (value->Type == JSON_Array)
{
// truncate the existing array if fewer entries provided
int num_existing_vals = value->GetArraySize();
for (int i=num_vals; i<num_existing_vals; i++)
value->RemoveLast();
JSON* item = value->GetFirstItem();
while (item && val_count < num_vals)
{
if (item->Type == JSON_Number)
item->dValue = vals[val_count];
item = value->GetNextItem(item);
val_count++;
}
}
else
{
return; // Maybe we should change the data type?
}
}
else
{
value = JSON::CreateArray();
value->Name = key;
Values.PushBack(value);
ValMap.Set(key, value);
}
for (; val_count < num_vals; val_count++)
value->AddArrayNumber(vals[val_count]);
}
//-----------------------------------------------------------------------------
bool ProfileManager::SetTaggedProfile(const char** tag_names, const char** tags, int num_tags, Profile* profile)
{
Lock::Locker lockScope(&ProfileLock);
if (ProfileCache == NULL)
{ // Load the cache
LoadCache(true);
if (ProfileCache == NULL)
return false; // TODO: Generate a new profile DB
}
JSON* tagged_data = ProfileCache->GetItemByName("TaggedData");
OVR_ASSERT(tagged_data);
if (tagged_data == NULL)
return false;
// Get the cached tagged data section
JSON* vals = FindTaggedData(tagged_data, tag_names, tags, num_tags);
if (vals == NULL)
{
JSON* tagged_item = JSON::CreateObject();
JSON* taglist = JSON::CreateArray();
for (int i=0; i<num_tags; i++)
{
JSON* k = JSON::CreateObject();
k->AddStringItem(tag_names[i], tags[i]);
taglist->AddArrayElement(k);
}
vals = JSON::CreateObject();
tagged_item->AddItem("tags", taglist);
tagged_item->AddItem("vals", vals);
tagged_data->AddArrayElement(tagged_item);
}
// Now add or update each profile setting in cache
for (unsigned int i=0; i<profile->Values.GetSize(); i++)
{
JSON* value = profile->Values[i];
bool found = false;
JSON* item = vals->GetFirstItem();
while (item)
{
if (value->Name == item->Name)
{
// Don't allow a pre-existing type to be overridden
OVR_ASSERT(value->Type == item->Type);
if (value->Type == item->Type)
{ // Check for the same value
if (value->Type == JSON_Array)
{ // Update each array item
if (item->GetArraySize() == value->GetArraySize())
{ // Update each value (assumed to be basic types and not array of objects)
JSON* value_element = value->GetFirstItem();
JSON* item_element = item->GetFirstItem();
while (item_element && value_element)
{
if (value_element->Type == JSON_String)
{
if (item_element->Value != value_element->Value)
{ // Overwrite the changed value and mark for file update
item_element->Value = value_element->Value;
Changed = true;
}
}
else {
if (item_element->dValue != value_element->dValue)
{ // Overwrite the changed value and mark for file update
item_element->dValue = value_element->dValue;
Changed = true;
}
}
value_element = value->GetNextItem(value_element);
item_element = item->GetNextItem(item_element);
}
}
else
{ // if the array size changed, simply create a new one
// TODO: Create the new array
}
}
else if (value->Type == JSON_String)
{
if (item->Value != value->Value)
{ // Overwrite the changed value and mark for file update
item->Value = value->Value;
Changed = true;
}
}
else {
if (item->dValue != value->dValue)
{ // Overwrite the changed value and mark for file update
item->dValue = value->dValue;
Changed = true;
}
}
}
else
{
return false;
}
found = true;
break;
}
item = vals->GetNextItem(item);
}
if (!found)
{ // Add the new value
Changed = true;
if (value->Type == JSON_String)
vals->AddStringItem(value->Name, value->Value);
else if (value->Type == JSON_Bool)
vals->AddBoolItem(value->Name, ((int)value->dValue != 0));
else if (value->Type == JSON_Number)
vals->AddNumberItem(value->Name, value->dValue);
else if (value->Type == JSON_Array)
vals->AddItem(value->Name, value->Copy());
else
{
OVR_ASSERT(false);
Changed = false;
}
}
}
return true;
}
bool ProductInfo::FromJson(JSON* pJsonNode)
{
bool bRet = false;
if (NameFromJson(pJsonNode) &&
URLFromJson(pJsonNode) &&
IDFromJson(pJsonNode))
{
JSON *pDisplay = pJsonNode->GetItemByName("Display");
JSON *pLensSeparation = pJsonNode->GetItemByName("LensSeparation");
JSON *pMobilePositon = pJsonNode->GetItemByName("MobilePositon");
JSON *pGlassID = pJsonNode->GetItemByName("GlassID");
JSON *pOS = pJsonNode->GetItemByName("OS");
JSON *pMachineID = pJsonNode->GetItemByName("MachineID");
if (pDisplay && ParseLanguageDisplay(&m_Display, pDisplay) &&
pGlassID && ParseIDList(&m_AllGlassID, pGlassID))
{
if (pLensSeparation && pLensSeparation->Type == JSON_Array && pLensSeparation->GetArraySize() >= 1 && pLensSeparation->GetArraySize() <= 3)
{
if (pLensSeparation->GetArraySize() == 1)
{
SetLensSeparation(pLensSeparation->GetArrayNumber(0));
SetLensSeparationMin(pLensSeparation->GetArrayNumber(0));
SetLensSeparationMax(pLensSeparation->GetArrayNumber(0));
}
else if (pLensSeparation->GetArraySize() == 2)
{
SetLensSeparation((pLensSeparation->GetArrayNumber(0) + pLensSeparation->GetArrayNumber(1)) / 2);
SetLensSeparationMin(pLensSeparation->GetArrayNumber(0));
SetLensSeparationMax(pLensSeparation->GetArrayNumber(1));
}
else if (pLensSeparation->GetArraySize() == 3)
{
SetLensSeparation(pLensSeparation->GetArrayNumber(2));
SetLensSeparationMin(pLensSeparation->GetArrayNumber(0));
SetLensSeparationMax(pLensSeparation->GetArrayNumber(1));
}
/*以下是可选参数*/
if (pMobilePositon && pMobilePositon->Type == JSON_Array)
{// 手机摆放位置
for (int i = 0; i < pMobilePositon->GetArraySize(); i++)
{
MobilePositionInfo *pNewItem = new MobilePositionInfo;
if (pNewItem->FromJson(pMobilePositon->GetItemByIndex(i)))
{
m_MobilePositon.push_back(pNewItem);
}
else
{
delete pNewItem;
}
}
}
if (pOS && pOS->Type == JSON_String)
{
SetOS(pOS->GetStringValue());
}
// if (pBrand && pBrand->Type == JSON_String)
// {
// SetBrand(pBrand->GetStringValue());
// }
// if (pModel && pModel->Type == JSON_String)
// {
// SetModel(pModel->GetStringValue());
// }
if (pMachineID && pMachineID->Type == JSON_Number)
{
SetMachineID(pMachineID->GetInt32Value());
}
bRet = true;
}// LensSeparation
}// Display,GlassID
}// Name , URL , ID
return bRet;
}
