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::LineIterator INIFile::getSectionLastLine(const String& section_name)
{
if (!section_index_.has(section_name))
{
return LineIterator();
}
SectionIterator sit = getSection(section_name);
list<String >::iterator line_it(sit->lines_.end());
if (sit->lines_.size() > 0) line_it--;
return LineIterator(sections_, getSection(section_name), line_it);
}
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;
}
}
INIFile::Key* INIFile::getKey(const std::string& sectionname, const std::string& keyname) const {
INIFile::Section* curSection = getSection(sectionname);
if(curSection == NULL) {
return NULL;
}
return curSection->getKey(keyname);
}
/**
This method returns a key iterator pointing at the first key in the specified section.
\param section the section to iterate over
\return the iterator
*/
INIFile::KeyIterator INIFile::begin(const std::string& section) const {
Section* curSection = getSection(section);
if(curSection == NULL) {
return KeyIterator(NULL);
} else {
return KeyIterator(curSection->KeyRoot);
}
}
void FifoIndex::insert(RowHandle *rh)
{
RhSection *rs = getSection(rh);
if (first_ == NULL) {
rs->next_ = NULL;
rs->prev_ = NULL;
first_ = last_ = rh;
} else {
rs->next_ = NULL;
rs->prev_ = last_;
RhSection *lastrs = getSection(last_);
lastrs->next_ = rh;
last_ = rh;
}
++size_;
}
/**
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>
IniFile::KeyListHandle myHandle;<br>
myHandle = myIniFile.KeyList_Open("Section1");<br>
<br>
while(!myIniFile.KeyList_EOF(myHandle)) {<br>
cout << myIniFile.KeyList_GetNextKey(&myHandle) << std::endl;<br>
}<br>
<br>
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 §ion) {
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 ConfigFile::hasKey(const String &key, const String §ion) const {
assert(isValidName(key));
assert(isValidName(section));
const Section *s = getSection(section);
if (!s)
return false;
return s->hasKey(key);
}
bool KLUPD::IniFile::createSection(const NoCaseString §ionName, 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;
}
}
/**
This method checks whether the specified key exists in the specified section.
\param section sectionname
\param key keyname
\return true, if the key exists, false otherwise
*/
bool INIFile::hasKey(const std::string& section, const std::string& key) const
{
Section* curSection = getSection(section);
if(curSection == NULL) {
return false;
} else {
return curSection->hasKey(key);
}
}
RandomTileData::Section *RandomTileData::getSection(const char *name) {
for (int i = 0; i < sectionCount; i++) {
RandomTileData::Section *sect = getSection(i);
if (sect->getNameList()->contains(name))
return sect;
}
return 0;
}
//get first entry in a section with a particular name
ConfEntry* ConfFile::getEntry(const std::string& section, const std::string& key) {
ConfSection* sec = getSection(section);
if(sec==0) return 0;
ConfEntry* entry = sec->getEntry(key);
return entry;
}
//returns a list of all entries in a section with a particular name
ConfEntryList* ConfFile::getEntries(const std::string& section, const std::string& key) {
ConfSection* sec = getSection(section);
if(sec==0) return 0;
ConfEntryList* entryList = sec->getEntries(key);
return entryList;
}
//returns the first section with a particular name
void ConfFile::setEntry(const std::string& section, const std::string& key, const std::string& value) {
ConfSection* sec = getSection(section);
if(sec==0) {
sec = addSection(section);
}
sec->setEntry(key, value);
}
void ConfigFile::renameSection(const String &oldName, const String &newName) {
assert(isValidName(oldName));
assert(isValidName(newName));
Section *os = getSection(oldName);
const Section *ns = getSection(newName);
if (os) {
// HACK: For now we just print a warning, for more info see the TODO
// below.
if (ns)
warning("ConfigFile::renameSection: Section name \"%s\" already used", newName.c_str());
else
os->name = newName;
}
// TODO: Check here whether there already is a section with the
// new name. Not sure how to cope with that case, we could:
// - simply remove the existing "newName" section
// - error out
// - merge the two sections "oldName" and "newName"
}
void SettingsComponent::updatePossibleValues(const QString §ionID, const QString &key, const QVariantList &possibleValues)
{
SettingsSection* section = getSection(sectionID);
if (!section)
{
QLOG_ERROR() << "Section" << sectionID << "is unknown";
return;
}
section->updatePossibleValues(key, possibleValues);
QLOG_DEBUG() << "Updated possible values for:" << key << "to" << possibleValues;
}
RowHandle *FifoIndex::next(const RowHandle *cur) const
{
if (cur == NULL || !cur->isInTable())
return NULL;
RhSection *rs = getSection(cur);
if (type_->isReverse())
return rs->prev_;
else
return rs->next_;
}
void test_getSection(void)
{
char* content = " echo \"\
[TcpClient] \n\
LogicName = tcpClient1 \n\
DestIp = 127.0.0.1 \n\
DestPort = 1111 \n\
LocalPort = 8888 \n\
\n\
[TcpClient] \n\
LogicName = tcpClient2 \n\
DestIp = 127.0.0.1 \n\
DestPort = 2222 \n\
LocalPort = 9999 \n\
\n\
[TcpClient] \n\
LogicName = tcpClient3 \n\
DestIp = 127.0.0.1 \n\
DestPort = 3333 \n\
LocalPort = 1234 \n\" > commModule.conf";
system(content);
char section[MAX_LEN_SECTION] = {0};
int ret = getSection("./commModule.conf", 0, "TcpClient", section);
TEST_ASSERT_EQUAL_INT(3, ret);
memset(section, 0, MAX_LEN_SECTION);
ret = getSection("./commModule.conf", 1, "TcpClient", section);
TEST_ASSERT_EQUAL_INT(TOOLS_SUCCESS, ret);
TEST_ASSERT_EQUAL_STRING("[TcpClient] \nLogicName = tcpClient1 \nDestIp = 127.0.0.1 \nDestPort = 1111 \nLocalPort = 8888 \n\n", section);
memset(section, 0, MAX_LEN_SECTION);
ret = getSection("./commModule.conf", 2, "TcpClient", section);
TEST_ASSERT_EQUAL_INT(TOOLS_SUCCESS, ret);
TEST_ASSERT_EQUAL_STRING("[TcpClient] \nLogicName = tcpClient2 \nDestIp = 127.0.0.1 \nDestPort = 2222 \nLocalPort = 9999 \n\n", section);
memset(section, 0, MAX_LEN_SECTION);
ret = getSection("./commModule.conf", 3, "TcpClient", section);
TEST_ASSERT_EQUAL_INT(TOOLS_SUCCESS, ret);
TEST_ASSERT_EQUAL_STRING("[TcpClient] \nLogicName = tcpClient3 \nDestIp = 127.0.0.1 \nDestPort = 3333 \nLocalPort = 1234 \n\n", section);
}
bool ConfigFile::getKey(const String &key, const String §ion, String &value) const {
assert(isValidName(key));
assert(isValidName(section));
const Section *s = getSection(section);
if (!s)
return false;
const KeyValue *kv = s->getKey(key);
if (!kv)
return false;
value = kv->value;
return true;
}
