datacontainer.h

/****************************************************************************************
                                          datacontainer.h 
                                        -------------------
    copyright            : (C) 2006 Jean-Luc Perret - Pierre Mahé
    email                : jean-luc.perret@unine.ch - pierre.mahe@ensmp.fr
 ***************************************************************************************/

/****************************************************************************************
 *                                                                                      *
 *      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.              *
 *                                                                                      *
 *      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 library; if not, write to the Free Software             *
 *      Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA      *
 *                                                                                      *
 ****************************************************************************************/

#ifndef DATACONTAINER_H
#define DATACONTAINER_H

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

using namespace std;

using std::map;
using std::ostream;


#include "descriptor.h"
#include "cerror.h"

class DataContainer {
public:



        DataContainer();

        DataContainer( DataContainer& aDataContainer );
        //DataContainer& operator= (const DataContainer& aDataContainer);
        
        virtual ~DataContainer();




        bool hasStringDescriptor( string aLabel );

        bool hasFloatDescriptor( string aLabel );
        
        bool hasIntDescriptor( string aLabel );





        Descriptor< int >* addKindIntDescriptor( string aLabel, int aValue, string aUnit, string aComment );

        Descriptor< int >* addKindIntDescriptor(Descriptor< int>* aDescriptor);

        Descriptor< float >* addKindFloatDescriptor( string aLabel, float aValue, string aUnit, string aComment );

        Descriptor< float >* addKindFloatDescriptor(Descriptor< float>* aDescriptor);

        Descriptor< string >* addKindStringDescriptor( string aLabel, string aValue, string aUnit, string aComment );

        Descriptor< string >* addKindStringDescriptor(Descriptor< string>* aDescriptor);

        Descriptor< int >*  addIntDescriptor( string aLabel, int aValue, string aUnit, string aComment );

        Descriptor< float >*  addFloatDescriptor( string aLabel, float aValue, string aUnit, string aComment );

        Descriptor< string >*  addStringDescriptor( string aLabel, string aValue, string aUnit, string aComment );

        Descriptor< int >* setIntDescriptor(string aLabel, int aValue, string aUnit, string aComment, bool addIfMissing, bool silentError );

        Descriptor< float >* setFloatDescriptor(string aLabel, float aValue, string aUnit, string aComment, bool addIfMissing, bool silentError );

        Descriptor< string >* setStringDescriptor(string aLabel, string aValue, string aUnit, string aComment, bool addIfMissing, bool silentError);


        Descriptor< int >* getIntDescriptor( string aLabel, bool silentError = true ) throw( CError );


        long getPossibleValuesInIntDescriptor( string aDescriptorName, vector< int >* );

        Descriptor< float >* getFloatDescriptor( string aLabel, bool silentError = true  ) throw( CError );

        Descriptor< string >* getStringDescriptor( string aLabel, bool silentError = true  ) throw( CError );

        virtual bool deleteDescriptor( string aString, bool found = false );

        void deleteAllDescriptors();

        void addUnknownTypeDescriptor( string aName, string aValue );






        map< string, Descriptor< int >* >::iterator beginIntDescriptor(){ return( intDescriptors.begin() ); }
        map< string, Descriptor< int >* >::iterator endIntDescriptor(){ return( intDescriptors.end() ); }

        map< string, Descriptor< float >* >::iterator beginFloatDescriptor(){ return( floatDescriptors.begin() ); }
        map< string, Descriptor< float >* >::iterator endFloatDescriptor(){ return( floatDescriptors.end() ); }

        map< string, Descriptor< string >* >::iterator beginStringDescriptor(){ return( stringDescriptors.begin() ); }
        map< string, Descriptor< string >* >::iterator endStringDescriptor(){ return( stringDescriptors.end() ); }







        void describe() throw( CError );

        void describeShort() throw( CError );

protected:

        bool flagElement;

        void deleteAllKindDescriptors();


        // Data container provides two different Descriptors:
        //   - kind descriptors which are shared by a group of instances of DataContainers
        //   - descriptors which are unique to an instance of this class.

        //   Kind descriptors can be created on the heap by this class, but are never deleted.
        //       on the other hand descriptors are fully managed by this class. WARNING:
        //       Descriptors are deleted by the destructor of this class so they
        //   should not be used by reference from elsewhere.


        // DESCRIPTORS
        // Hash of pointers on Descriptor<> to store properties of an instance of
        // this class
        // Objects in the hash are created by the add***Descriptor function
        // Objects are deleted in the deleteDescriptor or the
        // deleteAllDescriptors functions (also called by the destructor)

        map< string, Descriptor< int >* > intDescriptors;

        map< string, Descriptor< float >* > floatDescriptors;
       
        map< string, Descriptor< string >* > stringDescriptors;


        // KIND DESCRIPTORS
        // Hashes of pointers on Descriptor<> to store properties shared by a group of
        // instances of this class. The values of these descriptors are shared among the group
        // of instances. Example: the kind descriptor symbol with value H
        // is shared among all hydrogen instances of the derived class atom.
        //
        // Objects in these maps can be created by the function
        // addKind***Descriptor( string aLabel, float aValue, string aUnit, string aComment )
        // which returns a pointer to the created descriptor.
        // An already created descriptor can also be included in the map by the function
        // addKind***Descriptor( descriptor& )
        
        map< string, Descriptor< int >* >* kindIntDescriptors;

        map< string, Descriptor< float >* >* kindFloatDescriptors;

        map< string, Descriptor< string >* >* kindStringDescriptors; // Hash of Desriptor<string>

        // Hashes of pointers on Descriptor<string>
        // use when datacontainer Class instances should only contain a reference to a Descriptor
        // map< string, Descriptor< int >* > intPDescriptors;
        // map< string, Descriptor< float >* > floatPDescriptors;
        // map< string, Descriptor< string >* > stringPDescriptors;

};
#endif

---