C++ ReadValue函数代码示例

void OGRDXFDataSource::ReadHeaderSection()

{
    char szLineBuf[257];
    int  nCode;

    while( (nCode = ReadValue( szLineBuf, sizeof(szLineBuf) )) > -1 
           && !EQUAL(szLineBuf,"ENDSEC") )
    {
        if( nCode != 9 )
            continue;

        CPLString osName = szLineBuf;

        ReadValue( szLineBuf, sizeof(szLineBuf) );

        CPLString osValue = szLineBuf;

        oHeaderVariables[osName] = osValue;
    }

    CPLDebug( "DXF", "Read %d header variables.", 
              (int) oHeaderVariables.size() );
}

int
NameAttributeText::Compare(WidgetAttributeText &attr, BPoseView *view)
{
	NameAttributeText *compareTo = dynamic_cast<NameAttributeText *>(&attr);

	ASSERT(compareTo);

	if (fValueDirty)
		ReadValue(&fFullValueText);

	if (NameAttributeText::sSortFolderNamesFirst)
		return fModel->CompareFolderNamesFirst(attr.TargetModel());

	return NaturalCompare(fFullValueText.String(), compareTo->ValueAsText(view));
}

bool
GenericAttributeText::CheckAttributeChanged()
{
	GenericValueStruct tmpValue = fValue;
	BString tmpString(fFullValueText);
	ReadValue(&fFullValueText);

	// fDirty could already be true, in that case we mustn't set it to
	// false, even if the attribute text hasn't changed
	bool changed = (fValue.int64t != tmpValue.int64t) || (tmpString != fFullValueText);
	if (changed)
		fDirty = true;

	return fDirty;
}

int
RealNameAttributeText::Compare(WidgetAttributeText& attr, BPoseView* view)
{
	RealNameAttributeText* compareTo
		= dynamic_cast<RealNameAttributeText*>(&attr);
	ThrowOnAssert(compareTo != NULL);

	if (fValueDirty)
		ReadValue(&fFullValueText);

	if (RealNameAttributeText::sSortFolderNamesFirst)
		return fModel->CompareFolderNamesFirst(attr.TargetModel());

	return NaturalCompare(fFullValueText.String(),
		compareTo->ValueAsText(view));
}

/*****************************************************************************
 * FUNCTION
 *  mmi_brw_recent_pages_read_sorting_method
 * DESCRIPTION
 *  Function to read settings from NVRAM
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_brw_recent_pages_read_sorting_method(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    S16 NvramError;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ReadValue(NVRAM_BRW_RECENT_PAGES_SORTING_METHOD, &(g_brw_cntx.sorting_method), DS_BYTE, &NvramError);
    if (g_brw_cntx.sorting_method == 0xFF)
    {
        g_brw_cntx.sorting_method = WAP_CUSTOM_CFG_DEFAULT_SORTING_METHOD;
        WriteValue(NVRAM_BRW_RECENT_PAGES_SORTING_METHOD, &(g_brw_cntx.sorting_method), DS_BYTE, &NvramError);
    }
}

    bool RegKey::ReadValueDW(const wchar_t* name, DWORD* value)
    {
        DCHECK(value);
        DWORD type = REG_DWORD;
        DWORD size = sizeof(DWORD);
        DWORD result = 0;
        if(ReadValue(name, &result, &size, &type) &&
            (type==REG_DWORD || type==REG_BINARY) &&
            size==sizeof(DWORD))
        {
            *value = result;
            return true;
        }

        return false;
    }

void CVisProp::ReadValue(CVisSDIStream& refsdistream, bool fOnlyValue,
		const void *pvReferenceOffset)
{
	if (fOnlyValue)
	{
		// We assume that the type and name have already been read and that
		// storage for the object has been allocated.
		assert(IsValid());
		if (IsArray())
		{
			void *pvObjFirst = PRefCntArray()->PvObjFirst();
			if ((pvReferenceOffset != 0) && (IsObjReference()))
			{
				pvObjFirst = (void *)
						(((BYTE *) pvObjFirst) + ((int) pvReferenceOffset));
			}

			m_pproptypeinfo->ReadObjArray(refsdistream, Dim(),
					pvObjFirst);
		}
		else
		{
			void *pvObj = PvObj();
			if ((pvReferenceOffset != 0) && (IsObjReference()))
			{
				pvObj = (void *)
						(((BYTE *) pvObj) + ((int) pvReferenceOffset));
			}

			m_pproptypeinfo->ReadObj(refsdistream, pvObj);
		}
	}
	else
	{
#ifndef VIS_NO_SD_STREAM
		// Need to read type and name and then create storate for object.
		std::string strType;
		std::string strName;
		bool fShared;
		CVisDim dim;
		refsdistream.ReadTypeNameAndDim(strType, strName, dim, &fShared);
		SetTypeNameAndDim(strType.c_str(), strName.c_str(), dim, fShared);
		ReadValue(refsdistream, true, pvReferenceOffset);
		refsdistream.EndObj();
#endif // VIS_NO_SD_STREAM
	}
}

	virtual void OnClick(Point pt, int widget, int click_count)
	{
		const NWidgetBase *wid = this->GetWidget<NWidgetBase>(CW_PANEL);
		uint btn = (pt.y - wid->pos_y - WD_FRAMERECT_TOP - this->header_height) / (FONT_HEIGHT_NORMAL + WD_PAR_VSEP_NORMAL);
		uint x = pt.x - wid->pos_x;
		bool rtl = _current_text_dir == TD_RTL;
		if (rtl) x = wid->current_x - x;

		if (btn >= lengthof(_cheats_ui)) return;

		const CheatEntry *ce = &_cheats_ui[btn];
		int value = (int32)ReadValue(ce->variable, ce->type);
		int oldvalue = value;

		if (btn == CHT_CHANGE_DATE && x >= 40) {
			/* Click at the date text directly. */
			SetDParam(0, value);
			ShowQueryString(STR_JUST_INT, STR_CHEAT_CHANGE_DATE_QUERY_CAPT, 8, this, CS_NUMERAL, QSF_ACCEPT_UNCHANGED);
			return;
		}

		/* Not clicking a button? */
		if (!IsInsideMM(x, 20, 40)) return;

		*ce->been_used = true;

		switch (ce->type) {
			case SLE_BOOL:
				value ^= 1;
				if (ce->proc != NULL) ce->proc(value, 0);
				break;

			default:
				/* Take whatever the function returns */
				value = ce->proc(value + ((x >= 30) ? 1 : -1), (x >= 30) ? 1 : -1);

				/* The first cheat (money), doesn't return a different value. */
				if (value != oldvalue || btn == CHT_MONEY) this->clicked = btn * 2 + 1 + ((x >= 30) != rtl ? 1 : 0);
				break;
		}

		if (value != oldvalue) WriteValue(ce->variable, ce->type, (int64)value);

		this->flags4 |= WF_TIMEOUT_BEGIN;

		this->SetDirty();
	}

    typename std::enable_if<is_map_container<T>::value>::type ReadObject(T&& t, Value& v)
    {
        using U = typename std::decay<T>::type;

        size_t sz = v.Size();
        for (size_t i = 0; i < sz; i++)
        {
            Value& element = v[i];

            typename U::key_type key;
            typename U::value_type::second_type value;
            ReadValue(key, element["0"], i); //key
            ReadObject(value, element["1"]); //value

            t.emplace(key, value);
        }
    }

        bool NDataReader::ReadValue(LPCTSTR name, DWORD& value)
        {
            nui::Base::NString data;
            if(!ReadValue(name, data))
                return false;
            if(data.GetLength() == 0)
                return false;

            bool result = false;
            if(data[0] == _T('#'))
            {
                if(data.GetLength() == 7)
                {
                    result = _sntscanf(data.GetData() + 1, 6, _T("%x"), &value) == 1;
                    value = Ui::MakeArgb(0xFF, (BYTE)((value & 0xFF0000) >> 16), (BYTE)((value & 0xFF00) >> 8), (BYTE)(value & 0xFF));
                }
                else if(data.GetLength() == 9)

static void RefreshAddresses(WATCHDATA *ptr, VARINFO *var, int address, THREAD *thread, int noscope)
{
    ptr->structNesting[ptr->nestingCount++] = var;
    while (var)
    {
        char buf[1048];
        int unscope = noscope;
        var->scope = ptr->structNesting[0]->scope;
        if (noscope)
            var->outofscope = TRUE;
        else
        {
            int val;
            var->outofscope = FALSE;
            if (thread)
                var->thread = thread;
            if (var->offset == -1)
            {
                DEBUG_INFO *dbg;
                int i;
                char name[2048];
                name[0] = 0;
                for (i=0; i < ptr->nestingCount-1; i++)
                    sprintf(name + strlen(name), "%s", ptr->structNesting[i]->structtag);
                sprintf(name + strlen(name), "@%s", var->membername);
                dbg = findDebug(ptr->structNesting[0]->scope->address);
                val = var->address = GetSymbolAddress(dbg, name);
                // static member data
            }
            else
            {
                val = var->address = address + var->offset;
            }
            if (var->constant)
                val = var->address;
            else if (var->pointer)
            {
                unscope = ((val = var->derefaddress) == -1 && !ReadValue(var->address, &val, 4, var)) || !val;
            }
            RefreshAddresses(ptr, var->subtype, val, thread, unscope);
        }
        var = var->link;
    }
    ptr->nestingCount--;
}

void
OpenWithRelationAttributeText::FitValue(BString* outString,
	const BPoseView* view)
{
	if (fValueDirty)
		ReadValue();

	ASSERT(view == fPoseView);
	const OpenWithPoseView* launchWithView
		= dynamic_cast<const OpenWithPoseView*>(view);
	if (launchWithView != NULL)
		launchWithView->OpenWithRelationDescription(fModel, &fRelationText);

	fOldWidth = fColumn->Width();
	fTruncatedWidth = TruncString(outString, fRelationText.String(),
		fRelationText.Length(), view, fOldWidth, B_TRUNCATE_END);
	fDirty = false;
}

// ELEMENT を読み込む
ELEMENT *ReadElement(BUF *b)
{
	UINT i;
	char name[MAX_ELEMENT_NAME_LEN + 1];
	UINT type, num_value;
	VALUE **values;
	ELEMENT *e;
	// 引数チェック
	if (b == NULL)
	{
		return NULL;
	}

	// 名前
	if (ReadBufStr(b, name, sizeof(name)) == false)
	{
		return NULL;
	}

	// 項目の種類
	type = ReadBufInt(b);

	// 項目数
	num_value = ReadBufInt(b);
	if (num_value > MAX_VALUE_NUM)
	{
		// 個数オーバー
		return NULL;
	}

	// VALUE
	values = (VALUE **)Malloc(sizeof(VALUE *) * num_value);
	for (i = 0;i < num_value;i++)
	{
		values[i] = ReadValue(b, type);
	}

	// ELEMENT を作成
	e = NewElement(name, type, num_value, values);

	Free(values);

	return e;
}

void OGRDXFDataSource::ReadLineTypeDefinition()

{
    char szLineBuf[257];
    int  nCode;
    CPLString osLineTypeName;
    CPLString osLineTypeDef;

    while( (nCode = ReadValue( szLineBuf, sizeof(szLineBuf) )) > 0 )
    {
        switch( nCode )
        {
          case 2:
            osLineTypeName = ACTextUnescape(szLineBuf,GetEncoding());
            break;

          case 49:
          {
              if( osLineTypeDef != "" )
                  osLineTypeDef += " ";

              if( szLineBuf[0] == '-' )
                  osLineTypeDef += szLineBuf+1;
              else
                  osLineTypeDef += szLineBuf;

              osLineTypeDef += "g";
          }
          break;
            
          default:
            break;
        }
    }

    if( osLineTypeDef != "" )
        oLineTypeTable[osLineTypeName] = osLineTypeDef;
    
    if( nCode == 0 )
        UnreadValue();
}

// Returns the key value as a bool type. Returns false if the key is
// not found.
bool IniFile::ReadBool(const string& mKey, const string& szSection, bool def_value)
{
	bool bValue = def_value;
	string mValue = ReadValue(mKey, szSection);

	if(mWasFound)
	{
		if ( mValue.find("1") 						== 0 	
				|| compareNoCase(mValue, "true") 	== 0 
				|| compareNoCase(mValue, "yes") 	== 0 )
		{
			bValue = true;
		}
        else
        {
        	bValue = false;
        }
	}	

	return bValue;
}