src/utils/PropertyMap.hpp

/*
 * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
 * 
 * Contact: oopse@oopse.org
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * All we ask is that proper credit is given for our work, which includes
 * - but is not limited to - adding the above copyright notice to the beginning
 * of your source code files, and to any copyright notice that you may distribute
 * with programs based on this work.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */
 
/**
 * @file PropertyMap.hpp
 * @author tlin
 * @date 09/21/2004
 * @time 9:20am
 * @version 1.0
 */
 
#ifndef UTIL_PROPERTYMAP_HPP
#define UTIL_PROPERTYMAP_HPP

#include <map>
#include <string>
#include <vector>

#include <utils/GenericData.hpp>

namespace oopse{

    /**
    * @class PropertyMap
    * PropertyMap class maintains a list of GenericData. Type of Property is actually GenericData.
    */
    class PropertyMap{
        public:

            /** trivial constructor */
            PropertyMap() {}

            /**
            * Virtual Destructor responsible for deleting all of the generc data in PropertyMap
            */
            virtual ~PropertyMap();

            /**
            * Adds property into property map
            *
            * @param genData GenericData to be added into PropertyMap
            *
            * @see #removeProperty
            * @see #clearProperties
            */
            void addProperty(GenericData* genData);

            /**
            * Removes property from PropertyMap by name
            *
            * @param propName the name of property to be removed
            *
            * @see #addProperty
            * @see #clearProperties
            */
            bool removeProperty(const std::string& propName);

            /**
            * clear all of the properties
            *
            * @see #addProperty
            * @see #removeProperty
            */
            void clearProperties();

            /**
            * Returns all names of properties
            *
            * @return all names of properties
            */
            std::vector<std::string> getPropertyNames();

            /**
            * Returns all of the properties in PropertyMap
            *
            * @return all of the properties in PropertyMap
            *
            * @see #getPropertyByName
            */      
            std::vector<GenericData*> getProperties();

            /**
            * Returns property 
            *
            * @param propName name of property
            *
            * @return a pointer point to property with propName. If no property named propName
            * exists, return NULL
            *
            * @see #getProperties
            */      
            GenericData* getPropertyByName(const std::string& propName);
            //template<typename T = GenericData*> T getPropertyByName(std:string& propName);

            protected:
            std::map<std::string, GenericData*> propMap_;

        private:

            /** prevent copy constructing */
            PropertyMap(const PropertyMap&);

            /** prevent copy assignment */
            PropertyMap& operator=(const PropertyMap&);
    };

}// namespace oopse
#endif //UTIL_PROPERTYMAP_HPP
Revision:	129
Committed:	Wed Oct 20 22:54:30 2004 UTC (20 years, 6 months ago) by tim
Original Path:	*trunk/src/utils/PropertyMap.hpp*
File size:	3934 byte(s)
Log Message:	GenericData and PropertyMap pass unit test.
#	User	Rev	Content
1	tim	73	/*
2			* Copyright (C) 2000-2004 Object Oriented Parallel Simulation Engine (OOPSE) project
3			*
4			* Contact: oopse@oopse.org
5			*
6			* This program is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public License
8			* as published by the Free Software Foundation; either version 2.1
9			* of the License, or (at your option) any later version.
10			* All we ask is that proper credit is given for our work, which includes
11			* - but is not limited to - adding the above copyright notice to the beginning
12			* of your source code files, and to any copyright notice that you may distribute
13			* with programs based on this work.
14			*
15			* This program is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU Lesser General Public License for more details.
19			*
20			* You should have received a copy of the GNU Lesser General Public License
21			* along with this program; if not, write to the Free Software
22			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23			*
24			*/
25
26			/**
27			* @file PropertyMap.hpp
28			* @author tlin
29			* @date 09/21/2004
30			* @time 9:20am
31			* @version 1.0
32			*/
33
34			#ifndef UTIL_PROPERTYMAP_HPP
35			#define UTIL_PROPERTYMAP_HPP
36
37			#include <map>
38			#include <string>
39			#include <vector>
40
41	tim	129	#include <utils/GenericData.hpp>
42	tim	73
43			namespace oopse{
44
45	tim	129	/**
46			* @class PropertyMap
47			* PropertyMap class maintains a list of GenericData. Type of Property is actually GenericData.
48			*/
49			class PropertyMap{
50			public:
51	tim	73
52	tim	129	/** trivial constructor */
53			PropertyMap() {}
54	tim	73
55	tim	129	/**
56			* Virtual Destructor responsible for deleting all of the generc data in PropertyMap
57			*/
58			virtual ~PropertyMap();
59	tim	73
60	tim	129	/**
61			* Adds property into property map
62			*
63			* @param genData GenericData to be added into PropertyMap
64			*
65			* @see #removeProperty
66			* @see #clearProperties
67			*/
68			void addProperty(GenericData* genData);
69	tim	73
70	tim	129	/**
71			* Removes property from PropertyMap by name
72			*
73			* @param propName the name of property to be removed
74			*
75			* @see #addProperty
76			* @see #clearProperties
77			*/
78			bool removeProperty(const std::string& propName);
79	tim	73
80	tim	129	/**
81			* clear all of the properties
82			*
83			* @see #addProperty
84			* @see #removeProperty
85			*/
86			void clearProperties();
87	tim	73
88	tim	129	/**
89			* Returns all names of properties
90			*
91			* @return all names of properties
92			*/
93			std::vector<std::string> getPropertyNames();
94	tim	73
95	tim	129	/**
96			* Returns all of the properties in PropertyMap
97			*
98			* @return all of the properties in PropertyMap
99			*
100			* @see #getPropertyByName
101			*/
102			std::vector<GenericData*> getProperties();
103	tim	73
104	tim	129	/**
105			* Returns property
106			*
107			* @param propName name of property
108			*
109			* @return a pointer point to property with propName. If no property named propName
110			* exists, return NULL
111			*
112			* @see #getProperties
113			*/
114			GenericData* getPropertyByName(const std::string& propName);
115			//template<typename T = GenericData*> T getPropertyByName(std:string& propName);
116	tim	73
117	tim	129	protected:
118			std::map<std::string, GenericData*> propMap_;
119	tim	73
120	tim	129	private:
121	tim	73
122	tim	129	/** prevent copy constructing */
123			PropertyMap(const PropertyMap&);
124
125			/** prevent copy assignment */
126			PropertyMap& operator=(const PropertyMap&);
127			};
128
129	tim	73	}// namespace oopse
130			#endif //UTIL_PROPERTYMAP_HPP