directorymap.h

JAPAN RTOS TOPPERS/JSP kernel 1.4 PreRelease simulation environment JSP kernel Windows simulation

/*
 *  TOPPERS/JSP Kernel
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      Just Standard Profile Kernel
 * 
 *  Copyright (C) 2000-2003 by Embedded and Real-Time Systems Laboratory
 *                              Toyohashi Univ. of Technology, JAPAN
 * 
 *  忋婰挊嶌尃幰偼丆埲壓偺 (1)乣(4) 偺忦審偐丆Free Software Foundation 
 *  偵傛偭偰岞昞偝傟偰偄傞 GNU General Public License 偺 Version 2 偵婰
 *  弎偝傟偰偄傞忦審傪枮偨偡応崌偵尷傝丆杮僜僼僩僂僃傾乮杮僜僼僩僂僃傾
 *  傪夵曄偟偨傕偺傪娷傓丏埲壓摨偠乯傪巊梡丒暋惢丒夵曄丒嵞攝晍乮埲壓丆
 *  棙梡偲屇傇乯偡傞偙偲傪柍彏偱嫋戻偡傞丏
 *  (1) 杮僜僼僩僂僃傾傪僜乕僗僐乕僪偺宍偱棙梡偡傞応崌偵偼丆忋婰偺挊嶌
 *      尃昞帵丆偙偺棙梡忦審偍傛傃壓婰偺柍曐徹婯掕偑丆偦偺傑傑偺宍偱僜乕
 *      僗僐乕僪拞偵娷傑傟偰偄傞偙偲丏
 *  (2) 杮僜僼僩僂僃傾傪丆儔僀僽儔儕宍幃側偳丆懠偺僜僼僩僂僃傾奐敪偵巊
 *      梡偱偒傞宍偱嵞攝晍偡傞応崌偵偼丆嵞攝晍偵敽偆僪僉儏儊儞僩乮棙梡
 *      幰儅僯儏傾儖側偳乯偵丆忋婰偺挊嶌尃昞帵丆偙偺棙梡忦審偍傛傃壓婰
 *      偺柍曐徹婯掕傪宖嵹偡傞偙偲丏
 *  (3) 杮僜僼僩僂僃傾傪丆婡婍偵慻傒崬傓側偳丆懠偺僜僼僩僂僃傾奐敪偵巊
 *      梡偱偒側偄宍偱嵞攝晍偡傞応崌偵偼丆師偺偄偢傟偐偺忦審傪枮偨偡偙
 *      偲丏
 *    (a) 嵞攝晍偵敽偆僪僉儏儊儞僩乮棙梡幰儅僯儏傾儖側偳乯偵丆忋婰偺挊
 *        嶌尃昞帵丆偙偺棙梡忦審偍傛傃壓婰偺柍曐徹婯掕傪宖嵹偡傞偙偲丏
 *    (b) 嵞攝晍偺宍懺傪丆暿偵掕傔傞曽朄偵傛偭偰丆TOPPERS僾儘僕僃僋僩偵
 *        曬崘偡傞偙偲丏
 *  (4) 杮僜僼僩僂僃傾偺棙梡偵傛傝捈愙揑傑偨偼娫愙揑偵惗偠傞偄偐側傞懝
 *      奞偐傜傕丆忋婰挊嶌尃幰偍傛傃TOPPERS僾儘僕僃僋僩傪柶愑偡傞偙偲丏
 * 
 *  杮僜僼僩僂僃傾偼丆柍曐徹偱採嫙偝傟偰偄傞傕偺偱偁傞丏忋婰挊嶌尃幰偍
 *  傛傃TOPPERS僾儘僕僃僋僩偼丆杮僜僼僩僂僃傾偵娭偟偰丆偦偺揔梡壜擻惈傕
 *  娷傔偰丆偄偐側傞曐徹傕峴傢側偄丏傑偨丆杮僜僼僩僂僃傾偺棙梡偵傛傝捈
 *  愙揑傑偨偼娫愙揑偵惗偠偨偄偐側傞懝奞偵娭偟偰傕丆偦偺愑擟傪晧傢側偄丏
 * 
 *  @(#) $Id: directorymap.h,v 1.6 2003/06/30 12:50:32 takayuki Exp $
 */



// $Header: /home/CVS/configurator/base/directorymap.h,v 1.6 2003/06/30 12:50:32 takayuki Exp $

#ifndef DIRECTORYMAP_H
#define DIRECTORYMAP_H

#ifdef _MSC_VER
	#pragma warning(disable:4786)
#endif

#include "base/message.h"
#include "base/garbage.h"

  //MSVC6.0偑 <cstdio> 偟偰傕std偵擖傟偰偔傟側偄偺偱
#include <stdio.h>

#include <string>
#include <map>
#include <iostream>

class Directory : public std::map<std::string, Directory *>
{
private:
	/*
	 * Directory僋儔僗 : 愝寁儊儌
	 *
	 *   丒恊巕僲乕僪娫偺娭學
	 *		惗惉 : 恊偑 巕傪捈愙偄偠偭偰儕儞僋傪挘傞
	 *		攋婞 : 巕偑 恊偐傜偺撈棫傪埶棅偡傞 (恊偐傜堦曽揑偵姩摉偟側偄)
	 *
	 *   丒NULL僙乕僼幚憰
	 *      堦晹偺娭悢偼 this != NULL 傪壖掕偟側偄偱幚憰偡傞 (帺暘傊偺棙曋惈岦忋)
	 *        - addChild
	 *        - findChild, openChild (findNode()
	 *        - erase(void)
	 *        - getFirstChild, getLastChild, getNext, getPrev
	 */

public:
	enum tagtype
	{
		UNKNOWN,
		POINTER,
		INTEGER,
		LITERAL,
		CONSTLITERAL,
		OBJECT
	};

	enum tagflag
	{
		NOTHING  = 0,
		DESTRUCT = 1,
		UNSIGNED = 2
	};

	enum tagmode
	{
		PTRPREFIX = 1
	};

protected:
	static int defaultflag;

	enum tagtype type;
	int flag;

	Directory * parent;
	std::map<std::string, Directory *>::iterator myself;

	union
	{
		void * pointer;
		long value;
		const char * const_literal;
		std::string * literal;
		class Garbage * instance;
	} content;

    Directory(const Directory &);
    void initialize(void);
	void clearContent(void);

	Directory * findNode(bool, const std::string &);
    Directory * findNode(bool automatic_creation, const char * key, va_list vl);

public:
	Directory(void);
    Directory(int);
    Directory(long);
    Directory(const std::string &);
    Directory(void *);
    explicit Directory(const char *);
    explicit Directory(Garbage *);
	~Directory(void);

	Directory & operator =(void *);
	Directory & operator =(long);
	Directory & operator =(const char *);
	Directory & operator =(const std::string &);
	Directory & operator =(Garbage *);

    bool operator == (enum tagtype cmptype)
    {   return type == cmptype;   };

	Directory * operator ()(const std::string & src)
	{	return findChild(src);	};
	Directory * operator ()(const char * src)
	{	return findChild(src);	};

	Directory & operator [](const std::string & src)
	{	return *openChild(src);	};
	Directory & operator [](const char * src)
	{	return *openChild(std::string(src));	};

	enum tagtype getType(void) const { return type; };
	Directory *  getParent(void) const { return parent; };
    Directory *  getParent(int) const;
	Directory *  getNext(void) const;
	Directory *  getPrev(void) const;
    Directory *  getFirstChild(void) const;
    Directory *  getLastChild(void) const;
    Directory *  findChild(const std::string &);
    Directory *  findChild(const char *);
    Directory *  findChild(const char *, const char * , ... );
    Directory *  findDescandant(const std::string &, unsigned int = 0xffffffff) const;
    Directory *  openChild(const std::string &);
    Directory *  openChild(const char *);
    Directory *  openChild(const char *, const char *, ... );

	void * operator new(size_t);
	void * operator * (void) const;

	operator const long (void) const;
	operator const unsigned long (void) const;
	operator const int (void) const;
	operator const unsigned int (void) const;
	operator const char (void) const;
	operator const unsigned char (void) const;
    operator const char * (void);
    operator const std::string & (void) const;
    operator const Garbage * (void) const;
    operator const void * (void) const;

	void * toPointer(const void * default_value = 0) const;
	long toInteger(const long default_value = 0) const;
	std::string toString(const std::string & default_value = "") const;

	bool operator == (int) const;
	bool operator == (const std::string &) const;
	bool operator == (const char *) const;

	template<class T>
	bool operator != (T src) const
	{	return !(this->operator ==(src));	};


	Directory * addChild(const std::string &, Directory * = 0);
	Directory * addChild(const char *, Directory * = 0);
	Directory * addChild(const std::string &, Directory &);
	Directory * addChild(const char *, Directory &);
	Directory * addChild(Directory &);
	Directory * addChild(Directory * = 0);

    void erase(void);
	iterator erase(iterator);
	void disconnect(void);
    void copyTo(Directory *, int = 0x7fffffff);
	void dropValue(void);
	std::map<std::string, Directory *>::size_type size(std::map<std::string, Directory *>::size_type = 0) const;

	const std::string getKey(void) const;
	bool changeKey(const std::string &);
	bool changeKey(const char *);

    void Load(std::istream *);
    void Store(std::ostream *);

	void drawTree(std::ostream * = &std::cerr, int = 0, std::string * = 0);
	void drawTree_byXML(std::ostream * = &std::cerr, int = 0);

	std::string format(const char *, int mode = 0);
	std::string format(const std::string &, int mode = 0);
};


//------

inline void Directory::initialize(void)
{
    parent = 0;
    type = UNKNOWN;
    flag = defaultflag;
    content.pointer = 0;
    defaultflag &= ~DESTRUCT;
}

inline Directory::Directory(void)
{   initialize();    }

inline Directory::Directory(long val)
{
    initialize();
    *this = val;
}

inline Directory::Directory(int val)
{
    initialize();
    *this = (long)val;
}

inline Directory::Directory(void * val)
{
    initialize();
    *this = val;
}

inline Directory::Directory(const std::string & val)
{
    initialize();
    *this = val;
}

inline Directory::Directory(const char * val)
{
    initialize();
    *this = val;
}

inline Directory::Directory(Garbage * val)
{
    initialize();
    *this = val;
}

inline Directory * Directory::addChild(const char * key, Directory * node)
{	return addChild(std::string(key), node);	}

inline Directory * Directory::addChild(const std::string & key, Directory & node)
{	return addChild(key, &node);	}

inline Directory * Directory::addChild(const char * key, Directory & node)
{	return addChild(std::string(key), &node);	}

inline Directory * Directory::addChild(Directory & node)
{	return addChild(&node);	}

	//偙偺addChild偱捛壛偟偨梫慺偼丄堦妵嶍彍偡傞偐丄徚偟偰偼偄偗側偄
inline Directory * Directory::addChild(Directory * node)
{
	char buffer[32];
	sprintf(buffer,"%03d", size());
	return addChild(buffer, node);
}

inline bool Directory::changeKey(const char * key)
{	return changeKey(std::string(key));	}

inline const std::string Directory::getKey(void) const
{
	if(parent == 0)
		return std::string("/");
	return (*myself).first;
}

inline Directory::operator const unsigned long (void) const
{   return static_cast<const unsigned long>(this->operator const long());  }

inline Directory::operator const int (void) const
{   return static_cast<const int>(this->operator const long());  }

inline Directory::operator const unsigned int (void) const
{   return static_cast<const unsigned int>(this->operator const long());  }

inline Directory::operator const char (void) const
{   return static_cast<const char>(this->operator const long());  }

inline Directory::operator const unsigned char (void) const
{   return static_cast<const unsigned char>(this->operator const long());  }

inline Directory::operator const char * (void)
{
    if(type == CONSTLITERAL)
        return content.const_literal;
    if(type == LITERAL)
        return content.literal->c_str();
    ExceptionMessage("Bad cast exception raised","晄惓僉儍僗僩椺奜").throwException();
    return 0;
}

inline Directory::operator const std::string &(void) const
{
    if(type == LITERAL)
        return *content.literal;
    ExceptionMessage("Bad cast exception raised","晄惓僉儍僗僩椺奜").throwException();
	return *(std::string *)0;
}

inline Directory::operator const Garbage * (void) const
{
    if(type == OBJECT)
        return content.instance;
    ExceptionMessage("Bad cast exception raised","晄惓僉儍僗僩椺奜").throwException();
    return 0;
}

inline Directory::operator const void * (void) const
{   return **this;  }

inline Directory * Directory::findChild(const std::string & path)
{   return findNode(false, path);  }

inline Directory * Directory::openChild(const std::string & path)
{   return findNode(true, path);  }

inline Directory * Directory::getParent(int level) const
{
    const Directory * node = this;
    while(level-- > 0 && node != 0)
        node = node->parent;
    return const_cast<Directory *>(node);
}

inline Directory * Directory::getFirstChild(void) const
{
    if(this == 0 || size()== 0)
	    return 0;
	return (*begin()).second;
}

inline Directory * Directory::getLastChild(void) const
{
    if(this == 0 || size()== 0)
	    return 0;
	return (*rbegin()).second;
}

inline bool Directory::operator == (int src) const
{	return type == INTEGER && content.value == src;	}

inline bool Directory::operator == (const std::string & src) const
{	return (type == LITERAL && src.compare(*content.literal) == 0) || (type == CONSTLITERAL && src.compare(content.const_literal) == 0);	}

inline bool Directory::operator == (const char * src) const
{	return (type == LITERAL && content.literal->compare(src) == 0) || (type == CONSTLITERAL && strcmp(content.const_literal, src)== 0);	}

inline std::string Directory::format(const char * src, int mode)
{	return format(std::string(src), mode);	}

inline void Directory::dropValue(void)
{	clearContent();   }

#endif