| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef _DECAF_UTIL_PROPERTIES_H_ |
| #define _DECAF_UTIL_PROPERTIES_H_ |
| |
| #include <map> |
| #include <vector> |
| #include <string> |
| #include <sstream> |
| #include <decaf/util/Config.h> |
| |
| namespace decaf{ |
| namespace util{ |
| |
| /** |
| * Java-like properties class for mapping string names to string values. |
| */ |
| class DECAF_API Properties{ |
| private: |
| |
| std::map< std::string, std::string > properties; |
| |
| public: |
| |
| virtual ~Properties(){} |
| |
| /** |
| * Returns true if the properties object is empty |
| * @return true if empty |
| */ |
| virtual bool isEmpty() const { |
| return properties.empty(); |
| } |
| |
| /** |
| * Looks up the value for the given property. |
| * @param name The name of the property to be looked up. |
| * @return the value of the property with the given name, if it |
| * exists. If it does not exist, returns NULL. |
| */ |
| virtual const char* getProperty( const std::string& name ) const{ |
| |
| std::map< std::string, std::string >::const_iterator iter = |
| properties.find( name ); |
| if( iter == properties.end() ){ |
| return NULL; |
| } |
| |
| return iter->second.c_str(); |
| } |
| |
| /** |
| * Looks up the value for the given property. |
| * @param name the name of the property to be looked up. |
| * @param defaultValue The value to be returned if the given |
| * property does not exist. |
| * @return The value of the property specified by <code>name</code>, if it |
| * exists, otherwise the <code>defaultValue</code>. |
| */ |
| virtual std::string getProperty( const std::string& name, |
| const std::string& defaultValue ) const { |
| |
| std::map< std::string, std::string >::const_iterator iter = |
| properties.find( name ); |
| if( iter == properties.end() ){ |
| return defaultValue; |
| } |
| |
| return iter->second; |
| } |
| |
| /** |
| * Sets the value for a given property. If the property already |
| * exists, overwrites the value. |
| * @param name The name of the value to be written. |
| * @param value The value to be written. |
| */ |
| virtual void setProperty( const std::string& name, |
| const std::string& value ){ |
| properties[name] = value; |
| //properties.insert( std::make_pair( name, value ) ); |
| } |
| |
| /** |
| * Check to see if the Property exists in the set |
| * @param name - property name to check for in this properties set. |
| * @return true if property exists, false otherwise. |
| */ |
| virtual bool hasProperty( const std::string& name ) const |
| { |
| if(properties.find(name) != properties.end()) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Removes the property with the given name. |
| * @param name the name of the property to remove. |
| */ |
| virtual void remove( const std::string& name ){ |
| properties.erase( name ); |
| } |
| |
| /** |
| * Method that serializes the contents of the property map to |
| * an arryay. |
| * @return list of pairs where the first is the name and the second |
| * is the value. |
| */ |
| virtual std::vector< std::pair< std::string, std::string > > toArray() const{ |
| |
| // Create a vector big enough to hold all the elements in the map. |
| std::vector< std::pair<std::string, std::string> > vec( |
| properties.begin(), properties.end() ); |
| |
| return vec; |
| } |
| |
| /** |
| * Copies the contents of the given properties object to this one. |
| * @param source The source properties object. |
| */ |
| virtual void copy( const Properties* source ){ |
| |
| clear(); |
| this->properties = source->properties; |
| } |
| |
| /** |
| * Clones this object. |
| * @returns a replica of this object. |
| */ |
| virtual Properties* clone() const{ |
| |
| Properties* props = new Properties(); |
| |
| props->properties = properties; |
| |
| return props; |
| } |
| |
| /** |
| * Clears all properties from the map. |
| */ |
| virtual void clear(){ |
| properties.clear(); |
| } |
| |
| /** |
| * Formats the contents of the Properties Object into a string |
| * that can be logged, etc. |
| * @returns string value of this object. |
| */ |
| virtual std::string toString() const { |
| |
| std::ostringstream stream; |
| std::map< std::string, std::string >::const_iterator iter; |
| |
| stream << "Begin Class activemq::util::Properties:" << std::endl; |
| |
| for( iter = properties.begin(); iter != properties.end(); ++iter ){ |
| stream << " properties[" << iter->first << "] = " |
| << iter->second << std::endl; |
| } |
| |
| stream << "End Class activemq::util::Properties:" << std::endl; |
| |
| return stream.str(); |
| } |
| |
| }; |
| |
| }} |
| |
| #endif /*_DECAF_UTIL_PROPERTIES_H_*/ |