Return to LanguageElementContainer.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

BUG#: 2656
TITLE: License statement update to 2005

DESCRIPTION: All .h, .cpp and the wql, cql, compile *.l and *.y files along
with the .java files in providermanager2/jmpi updated to use the license
statement in doc/license.txt
Tested on windows and visual test of all diffs.

//%2005////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_LanguageElementContainer_h
#define Pegasus_LanguageElementContainer_h


#include <cstdlib>
#include <cctype>

#ifdef PEGASUS_OS_HPUX
# ifdef HPUX_IA64_NATIVE_COMPILER
#  include <iostream>
# else
#  include <iostream.h>
# endif
#else
# include <iostream>
#endif

#include <Pegasus/Common/Linkage.h>
#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/String.h>
#include <Pegasus/Common/Array.h>
#include <Pegasus/Common/LanguageElement.h>
//#include <Pegasus/Common/LanguageParser.h>

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES

PEGASUS_NAMESPACE_BEGIN

class LanguageElementContainerRep;

//////////////////////////////////////////////////////////////
//
// LanguageElementContainer::
//
//////////////////////////////////////////////////////////////

/** <I><B>Experimental Interface</B></I><BR>
 * This class is a container class for LanguageElement
 */
class PEGASUS_COMMON_LINKAGE LanguageElementContainer{

public:

	/**	This member is used to represent an empty LanguageElementContainer. Using this 
        member avoids construction of an empty LanguageElementContainer 
        (e.g., LanguageElementContainer()).
	*/
	static const LanguageElementContainer EMPTY;
    
    /**
     * Default Constructor
     */
	LanguageElementContainer();    
	
	/**
	 * Constructor
	 * @param container Array<LanguageElement> - contructs the object with the elements in the array
	 */
	LanguageElementContainer(const Array<LanguageElement> & container);

	/** Copy Constructor
	 * @param rhs LanguageElementContainer
	 */
	LanguageElementContainer(const LanguageElementContainer &rhs);
	
	/**
	 * Destructor
	 */
	virtual ~LanguageElementContainer();
	
	/**
	 * Deep copy
	 * @param rhs LanguageElementContainer
	 */
	LanguageElementContainer operator=(const LanguageElementContainer &rhs);

	/** Gets an AcceptLanguageElement object at position index
	 * @param index int position of AcceptLanguageElement
	 * @return AcceptLanguageElement
	 */
	LanguageElement getLanguageElement(Uint32 index) const;

	/** Gets all AcceptLanguageElement objects in the container
	 * @return Array<AcceptLanguageElement>
	 */
	Array<LanguageElement> getAllLanguageElements() const;

	/** Returns the String representation of this container
	 * @return String
	 */
	virtual String toString() const;

	/** 
	 * Returns the length of the LanguageElementContainer object.
	 * @return Length of the container.
     */
    Uint32 size() const;

	/**
	 * True if the container has element (case INSENSITIVE match of element's language fields
	 * @param LanguageElement element 
	 * @return Boolean
	 */
	Boolean contains(LanguageElement element)const;

	/**
	 * Resets this object's iterator, should be called once before using itrNext()
	 */
	void itrStart();

	/**
	 * Returns the next element in the container
	 * Callers should call itrStart() ONCE before making calls to this function and
	 * anytime callers want the iterator reset to the beginning of the container.
	 * @return LanguageElement - the next element the container or LanguageElement::EMPTY_REF
	 * if the end of the container has been reached.
	 */
	LanguageElement itrNext();

	/**
	 * Removes the element at index from the container.  
	 * @param index Uint32 - position of the element in the container to remove
	 */
	void remove(Uint32 index);
	
	/**
	 * Removes the element matching the parameter, returns -1 if not found
	 * @param element LanguageElement - element to remove
	 * @return int  -1 if element not found, otherwise returns the position of element before the remove.
	 */
	Uint32 remove(const LanguageElement &element);

	/**
	 * Clears the container of all elements
	 */
	void clear();

	void append(LanguageElement element);

	/**
	 * Equality based on language fields only
	 */
	Boolean operator==(const LanguageElementContainer &rhs)const;

	/**
	 * Inequality based on language fields only
	 */
	Boolean operator!=(const LanguageElementContainer &rhs)const;
	
	/**
	 * Finds the element in the container and returns its position.
	 * @param element LanguageElement - element to find
	 * @return int index of element if found, otherwise -1
	 */
	//int find(LanguageElement element)const;

protected:

	LanguageElementContainerRep *_rep;
	
	       
}; // end LanguageElementContainer

PEGASUS_NAMESPACE_END

#endif  // PEGASUS_USE_EXPERIMENTAL_INTERFACE

#endif