C++ getSection函数代码示例

void FifoIndex::remove(RowHandle *rh)
{
    RhSection *rs = getSection(rh);

    if (first_ == rh) {
        if (last_ == rh) {
            first_ = last_ = NULL; // that was the last row
        } else {
            first_ = rs->next_;
            RhSection *nextrs = getSection(first_);
            nextrs->prev_ = NULL;
        }
    } else if (last_ == rh) {
        last_ = rs->prev_;
        RhSection *prevrs = getSection(last_);
        prevrs->next_ = NULL;
    } else {
        RhSection *nextrs = getSection(rs->next_);
        RhSection *prevrs = getSection(rs->prev_);
        prevrs->next_ = rs->next_;
        nextrs->prev_ = rs->prev_;
    }
    rs->prev_ = rs->next_ = NULL;
    --size_;
}

	void Parser::scan_section()
	{
		if (current_char != L_SECTION)
			return;

		std::string line = "";
		while (scan_char() && current_char != R_SECTION && current_char != NEWLINE)
		{
			line += current_char;
		}

		//Remember:
		// Section takes care of freeing the resources of its siblings
		// so new is actually safe here

		Section *section = new Section(line);

		//current_section might be a section, but if not, our ctor guarantees it to be NULL.
		section->previous = current_section;

        //Use current_section rather than the getter since we don't want it to instantiate.
		if (current_section)
		{
			section->previous = getSection();
			getSection()->next = section;
		}

		setSection(section);
	};

	INIFile::LineIterator INIFile::getSectionFirstLine(const String& section_name)
	{
		if (!section_index_.has(section_name)) 
		{
			return LineIterator();
		}

		return LineIterator(sections_, getSection(section_name), 
												 getSection(section_name)->lines_.begin());
	}

INIFile::Section* INIFile::getSectionOrCreate(const std::string& sectionname) {
	Section* curSection = getSection(sectionname);

	if(curSection == NULL) {
		// create new section

		if(isValidSectionName(sectionname) == false) {
			std::cerr << "INIFile: Cannot create section with name " << sectionname << "!" << std::endl;
			return NULL;
		}

		curSection = new Section(sectionname);

		if(FirstLine == NULL) {
			FirstLine = curSection;
		} else {
            INIFileLine* curLine = FirstLine;
			while(curLine->nextLine != NULL) {
				curLine = curLine->nextLine;
			}

			curLine->nextLine = curSection;
			curSection->prevLine = curLine;
		}

		InsertSection(curSection);
	}
    return curSection;
}

void Config::loadData(char *pbData, int iDatasize){
	int pointer = 0;
	while (pointer < iDatasize){
		char *line = GetNextLine(pbData, iDatasize, &pointer);
		//printf("Line: %s\r\n", line);
		/**/
		if (lineContainSection(line) == true){
			char *section = getSection(line);
			//printf("Section: [%s]\r\n", section);
			do{
				char *sectionDataLine = GetNextLine(pbData, iDatasize, &pointer);
				char *key = NULL;
				char *value = NULL;
				if (sectionDataLine != NULL){
					key = getKey(sectionDataLine);
					value = getValue(sectionDataLine);
					if (key != NULL && value != NULL){
						config.put(section, key, value);
						//printf(" (%s) = |%s|\r\n", key, value);
						//printf()
					}
						
				}
				
				if (sectionDataLine != NULL) delete[] sectionDataLine;
				//if (key != NULL) delete[] key;
				//if (value != NULL) delete[] value;
			}
			while (lineInCurrentSection(pbData, iDatasize, &pointer) == true);
			//if(section != NULL) delete[] section;

		}
		if(line!=NULL) delete[]line;
	}
}

std::vector<Section> File::sections(const util::Filter<Section>::type &filter) const
{
    auto f = [this] (ndsize_t i) { return getSection(i); };
    return getEntities<Section>(f,
                                sectionCount(),
                                filter);
}

bool FifoIndex::replacementPolicy(RowHandle *rh, RhSet &replaced)
{
    size_t limit = type_->getLimit();
    if (limit == 0)
        return true; // no limit, nothing replaced

    // Check if there is any row already marked for replacement and present in this index,
    // then don't push out another one.
    size_t subtract = 0;
    for (RhSet::iterator it = replaced.begin(); it != replaced.end(); ++it) {
        Index *rind = type_->findInstance(table_, *it);
        if (rind == this)
            ++subtract; // it belongs here, so a record will be already pushed out
    }

    if (size_ - subtract >= limit && size_ >= subtract) { // this works well only with one-at-a-time inserts
        if (type_->isJumping()) {
            RowHandle *curh = first_;
            while(curh != NULL) {
                replaced.insert(curh);

                RhSection *rs = getSection(curh);
                curh = rs->next_;
            }
        } else {
            replaced.insert(first_);
        }
    }

    return true;
}

/* ==========================================================================
	Function Name	: (HKEY) RegCreate()
	Outline			: 指定したレジストリキーを作成（またはオープン）する
	Arguments		: HKEY		hCurrentKey		(in)	現在のオープンキー
					: LPCTSTR	lpszKeyName		(in)	オープンするサブキーの
					: 									名前
	Return Value	: 成功	オープンまたは作成されたキーのハンドル
					: 失敗	NULL
	Reference		: 
	Renewal			: 
	Notes			: 
	Attention		: 
	Up Date			: 
   ======1=========2=========3=========4=========5=========6=========7======= */
HKEY RegCreate(HKEY hCurrentKey, LPCTSTR lpszKeyName)
{
	if(bUseINI){
		getSection(lpszKeyName);
		return ERROR_SUCCESS;
	}else{
		long	lError;
		HKEY	hkResult;
		DWORD	dwDisposition;

		lError = ::RegCreateKeyEx(hCurrentKey,
								lpszKeyName,
								0,
								NULL,
								REG_OPTION_NON_VOLATILE,
								KEY_ALL_ACCESS,
								NULL,
								&hkResult,
								&dwDisposition);
		if (lError != ERROR_SUCCESS) {
			::SetLastError(lError);
			return (HKEY) INVALID_HANDLE_VALUE;
		}

		return hkResult;
	}
}

/**
	A IniFile::KeyListHandle can be used to list all keys of one section. This method opens the #IniFile::KeyListHandle.
	To iterate all keys use KeyList_GetNextKey(). #IniFile::KeyListHandle should be closed by KeyList_Close().
	If the section is empty IniFile::KeyList_EOF on the returned handle of IniFile::KeyList_Open(sectionname) is true.<br>
	<br>
	Example:<br>
	&nbsp;&nbsp;IniFile::KeyListHandle myHandle;<br>
	&nbsp;&nbsp;myHandle = myIniFile.KeyList_Open("Section1");<br>
	<br>
	&nbsp;&nbsp;while(!myIniFile.KeyList_EOF(myHandle)) {<br>
	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;cout << myIniFile.KeyList_GetNextKey(&myHandle) << std::endl;<br>
	&nbsp;&nbsp;}<br>
	<br>
	&nbsp;&nbsp;myIniFile.KeyList_Close(&myHandle);
	\param	sectionname	The name of the section
	\return	handle to this section
	\see	KeyList_Close, KeyList_GetNextKey, KeyList_EOF
*/
IniFile::KeyListHandle IniFile::KeyList_Open(std::string sectionname) {
	SectionEntry *curSection = getSection(sectionname);
	if(curSection == nullptr) {
		return nullptr;
	} else {
		return curSection->KeyRoot;
	}
}

void CDirectiveConditional::Execute()
{
	bool b;

	switch (type)
	{
	case ConditionType::IFARM:
		b = Value == 1;
		Global.conditionData.addIf(b);
		break;
	case ConditionType::IFTHUMB:
		b = Value == 3;
		Global.conditionData.addIf(b);
		break;
	case ConditionType::IF:
		b = Value != 0;
		Global.conditionData.addIf(b);
		break;
	case ConditionType::ELSE:
		Global.conditionData.addElse();
		break;
	case ConditionType::ELSEIF:
		b = Value != 0;
		Global.conditionData.addElseIf(b);
		break;
	case ConditionType::ENDIF:
		Global.conditionData.addEndIf();
		break;
	case ConditionType::IFDEF:
		b = checkLabelDefined(labelName,getSection());
		Global.conditionData.addIf(b);
		break;
	case ConditionType::IFNDEF:
		b = !checkLabelDefined(labelName,getSection());
		Global.conditionData.addIf(b);
		break;
	case ConditionType::ELSEIFDEF:	
		b = checkLabelDefined(labelName,getSection());
		Global.conditionData.addElseIf(b);
		break;
	case ConditionType::ELSEIFNDEF:
		b = !checkLabelDefined(labelName,getSection());
		Global.conditionData.addElseIf(b);
		break;
	}
}

bool ConfFile::hasSection(const std::string& section) {

    ConfSection* sec = getSection(section);

    if(sec==0) return false;

    return true;
}

void ConfigFile::removeKey(const String &key, const String &section) {
	assert(isValidName(key));
	assert(isValidName(section));

	Section *s = getSection(section);
	if (s)
		 s->removeKey(key);
}

/* Copy variant which takes an IVal */
void
copy(Uint32* dst, Uint32 srcFirstIVal)
{
  SegmentedSectionPtr p;
  getSection(p, srcFirstIVal);

  copy(dst, p);
}

bool KLUPD::IniFile::createSection(const NoCaseString &sectionName, const NoCaseString &comment)
{
    if(getSection(sectionName))
        return false;

    m_sections.push_back(Section(sectionName, comment));
    m_dirty = true;
    return true;
}

size_t IniReader::getKeyCount(const std::string & sectionName) const {
	
	const IniSection * section = getSection(sectionName);
	if(section) {
		return section->size();
	} else {
		return 0;
	}
}