directorymap.cpp

嵌入式系统开发 TOPPERS and JSP Kernel Release 1.3 TOPPERS = Toyohashi Open Platform for Embedded Real-Tim

        *out << " : CSTR[" << content.const_literal << "]";
        break;
    case OBJECT:
        {
            *out << " : OBJ";
            break;
        }
    default:
        *out << "UNKNOWN";
    }
    *out << endl;
	(*link) += " | ";
	scope = begin();
	while(scope != end())
	{
		scope2 = scope;
		scope ++;

		if(scope == end())
			(*link)[level*3+1] = ' ';
		(*scope2).second->drawTree(out, level+1, link);
	}


	link->erase(level*3);
	if(level == 0)
		delete link;
}

Directory * Directory::findChild(const char * key)
{
    string work(key);
    if(work.find_first_of('/') != string::npos)
        return findChild(work);
    return _find(false, key, 0);
}

Directory * Directory::findChild(const char * key, const char * second, ... )
{
    va_list vl;
    va_start(vl, second);
	vl = (char *)vl - sizeof(const char *);
    return _find(false, key, vl);
}

Directory * Directory::openChild(const char * key)
{
    string work(key);
    if(work.find_first_of('/') != string::npos)
        return openChild(work);
    return _find(true, key, 0);
}


Directory * Directory::openChild(const char * key, const char * second, ... )
{
    va_list vl;
    va_start(vl, second);
	vl = (char *)vl - sizeof(const char *);
    return _find(true, key, vl);
}

    //回年したキ〖を积つ灰鹿を玫す。サ〖チ界は面界
Directory * Directory::findDescandant(const string & key, unsigned int level) const
{
    Directory::const_iterator scope;
    const Directory * node = this;

    if(empty())
        return 0;

        //灰で玫す
    scope = begin();
    while( scope != end() )
    {
        if((*scope).first.compare(key) == 0)
            return const_cast<Directory *>((*scope).second);
        scope ++;
    }

    if(level > 0)
    {
        scope = begin();
        while( scope != end() )
        {
            if((node = (*scope).second->findDescandant(key, level-1)) != 0)
                return const_cast<Directory *>(node);
            scope ++;
        }
    }
    return 0;
}

void Directory::copyTo(Directory * dest, int nest)
{
    Directory::iterator scope;
    Directory * node;

    node = dest;
    while(node != 0)
    {
        if(node == this)
            Exception("CopyTo: dest must not be a descendant node.","CopyTo: 灰鹿ノ〖ドへのコピ〖はできません");
        node = node->getParent();
    }

    scope = begin();
    while(scope != end())
    {
        node = dest->findChild((*scope).first);
        if(node != 0)
            node->erase();

        node = dest->addChild((*scope).first, new Directory(*(*scope).second));
        if(nest > 0)
            (*scope).second->copyTo(node, nest-1);

        scope++;
    }
}

 /*
  * ツリ〖のスナップショットを荒す。とりあえずベタ徘き。ポインタとかもそのまま。
  * 谁少なリソ〖ス(CPU,メモリ,ディスク)はプログラマをだめにする。
  */
void Directory::Store(ostream * out)
{
    int i;
    Directory * node;

    out->write((const char *)&type, sizeof(type));
    switch(type)
    {
    case INTEGER:
        out->write((const char *)&content.value, sizeof(content.value));
        break;
    case LITERAL:
        i = content.literal->size();
        out->write((const char *)&i, sizeof(int));
        out->write(content.literal->c_str(), i);
        break;
    case CONSTLITERAL:
        i = strlen(content.const_literal);
        out->write((const char *)&i, sizeof(int));
        out->write(content.const_literal, i);
        break;
    default:
        out->write((const char *)&content.pointer, sizeof(content.pointer));
    }
    i = size();
    out->write((const char *)&i, sizeof(int));
    for(node = getFirstChild(); node != 0; node = node->getNext())
    {
        const string & work = node->getKey();
        i = work.size();
        out->write((const char *)&i, sizeof(int));
        out->write(work.c_str(), i);
        node->Store(out);
    }
}

void Directory::Load(istream * in)
{
    int i;
    int count;
    char buffer[1024];

    in->read((char *)&type, sizeof(type));
    switch(type)
    {
    case INTEGER:
        in->read((char *)&content.value, sizeof(content.value));
        break;
    case CONSTLITERAL:
    case LITERAL:
        in->read((char *)&i, sizeof(int));
        in->read(buffer, i);
        buffer[i] = '\x0';
        *this = string(buffer);
        break;
    default:
        in->read((char *)&content.pointer, sizeof(content.pointer));
    }
    in->read((char *)&count, sizeof(int));
    while(count-- > 0)
    {
        in->read((char *)&i, sizeof(int));
        in->read(buffer, i);
        buffer[i] = '\x0';

        addChild(buffer)->Load(in);
    }
}

string Directory::toString(const string & _default) const
{
	if(this == 0)
		return _default;

	switch(type)
	{
	case POINTER:
	case OBJECT:
		{
			char buffer[256];
			sprintf(buffer,"%08lx", (long)content.pointer);
			return string(buffer);
		}
	case INTEGER:
		{
			char buffer[256];
			sprintf(buffer,"%ld", content.value);
			return string(buffer);
		}
	case CONSTLITERAL:
		return string(content.const_literal);
	case LITERAL:
		return string(*content.literal);
        default:
            return _default;
	}

	return _default;
}

void * Directory::toPointer(const void * _default) const
{
	if(this == 0)
		return (void *)_default;

	switch(type)
	{
	case INTEGER:
		return (void *)&content.value;
	case CONSTLITERAL:
		return (void *)content.const_literal;
	case LITERAL:
		return (void *)content.literal->c_str();
	case POINTER:
		return (void *)content.pointer;
	case OBJECT:
		return (void *)content.instance;
	default:
	    return (void *)_default;
	}

	return (void *)_default;
}

long Directory::toInteger(const long _default) const
{
	bool minus = false;
	long work;
	const char * str;

	if(this == 0)
		return _default;

	switch(type)
	{
	case INTEGER:
		return content.value;

	case POINTER:
		return (long)content.pointer;

	case LITERAL:
	case CONSTLITERAL:
		if(type == CONSTLITERAL)
			str = content.const_literal;
		else
			str = content.literal->c_str();

		if(*str == '-')
		{
			minus = true;
			str ++;
		}

		if(*str == '0')
		{
			str ++;
			if(*str == 'x' || *str == 'X')
			{
				if(sscanf(str+1, "%ux", (int *)&work) == 0)
					return _default;
			}else
				if(*str != '\x0')
				{
					if(sscanf(str, "%o", (int *)&work) == 0)
						return _default;
				}else
					return 0;
		}else
			if(sscanf(str, "%d", (int *)&work) == 0)
				return _default;

		if(minus)
			work = -work;
		return work;
	default:
		return _default;
	}

	return _default;
}

string Directory::format(const string & fmt)
{
	Directory * node;
	string work;
	string key;
	string::size_type top,tail;
	int i;


	tail = 0;
	while((top = fmt.find_first_of('$', tail)) != string::npos)
	{
		if(top != tail)
			work += fmt.substr(tail, top - tail);

		if(fmt[top+1] == '$')
		{
			tail = top+2;
			work += '$';
			continue;
		}

		if(fmt[top+1] == '@')
		{
			work += (*myself).first;
			tail = top + 2;
		}
			

		if(fmt[top+1] == '(')
		{
			i = fmt.find_first_of(')', top);
			key = fmt.substr(top+2, i - top - 2);
			if(key.find_first_of('$') != string::npos)
			{
				int j;

				if(key.find_first_of('(') != string::npos)
				{
					key += ')';
					key = format(key);
					j = fmt.find_first_of(')',i+1);
					key += fmt.substr(i+1, j - i - 1);
					i = j;
				}else
					key = format(key);
			}
			node = _find(false,key);
			if(node != 0)
				work += node->toString("(null)");
			else
				work += "(null)";

			tail = i+1;
			continue;
		}
	}

	work += fmt.substr(tail);

	return work;
}