collection.h

Go to the documentation of this file.

/* -*- mode: c++; c-basic-offset: 3 -*-
 *
 * Copyright (c), GREYC.
 * All rights reserved
 *
 * You may use this file under the terms of the BSD license as follows:
 *
 * "Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of the GREYC, nor the name of its
 *     contributors may be used to endorse or promote products
 *     derived from this software without specific prior written
 *     permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 *
 *
 * For more information, refer to:
 * https://clouard.users.greyc.fr/Pandore
 */

#ifndef __PCOLLECTIONH__
#define __PCOLLECTIONH__

#include <map>
#include <string>
#include <list>
#include "bundled.h"
#include <sstream>

namespace pandore {

   // Because VisualC++ cannot use template as: method<Type>(...)
   // we use the dummy 0 with the convenient casting.
   // So: change the prototype to: method(..., (type)0);
#define SETVALUE(name, type, val) SetValue((name), (val))
#define GETVALUE(name, type)      GetValue((name), (type*)0)

#define SETARRAY(name, type, val, size) SetArray((name), (val), (size))
#define GETARRAY(name, type)      GetArray((name), (type*)0)
#define GETARRAYSIZE(name, type)  GetArraySize((name), (type*)0)
#define GETNARRAYS(name, type, number, minsize_out) GetNArrays((name), (number), (minsize_out), (type*)0)

#define SETPOBJECT(name, type, val) SetPobject((name), (val))
#define GETPOBJECT(name, type)     GetPobject((name), (type*)0)

#define SETPARRAY(name, type, val, size) SetPArray((name), (val), (size))
#define GETPARRAY(name, type)      GetPArray((name), (type*)0)
#define GETPARRAYSIZE(name, type)  GetPArraySize((name), (type*)0)

   class Collection;


   /* @brief A trait that returns the name of the object Collection.
    *
    * TypeName is a trait that returns the name
    * of the object Collection.
    */
   template<>
   struct TypeName< Collection > {
         /*
          * Returns the name of the type.
          * @return     the string with the name.
          */
         static std::string Name() { return "Collection"; }
   };

   class Collection : public Pobject {
      public :

         ~Collection() { Delete(); }

         Typobj Type() const { return Po_Collection; }
   
         std::string Name() const { return TypeName< Collection >::Name(); }
   
         Pobject* Clone() const {
            std::map< std::string, BundledObject * >::const_iterator i;
            Collection *tmp = new Collection;
            for (i = _objs.begin(); i != _objs.end(); ++i) {
               tmp->Set(i->first, i->second->Clone());
            }
            return tmp;
         }

         Collection &operator=( const Collection &col ) {
            this->Delete();
            std::map< std::string, BundledObject * >::const_iterator i;
            for (i = col._objs.begin(); i != col._objs.end(); ++i) {
               this->Set(i->first, i->second->Clone());
            }
            return *this;
         }

         void Erase( const std::string &name ) {
            std::map< std::string, BundledObject * >::iterator i = _objs.find(name);
            if (i == _objs.end()) {
               return;  
            }
            delete i->second;
            _objs.erase(i);
         }
      
         void Delete( ) {
            std::map< std::string, BundledObject * >::iterator i;
            for (i = _objs.begin(); i != _objs.end(); ++i) {
               delete i->second;
            }
            _objs.clear();
         }

         void Rename( const std::string &oldname, const std::string &newname ) {
            std::map< std::string, BundledObject * >::iterator i = _objs.find(oldname);
            if (i == _objs.end()) {
               return;
            }
            _objs[newname] = i->second;
            _objs.erase(i);
         }

         bool Exists( const std::string &name ) const {
            std::map< std::string, BundledObject * >::const_iterator i = _objs.find(name);
            return i != _objs.end();
         }

         Errc NbOf( const std::string &name, std::string &type_out, Long &number_out, Long &minsize_out ) const;
   
         std::string GetType( const std::string &name ) const {
            BundledObject *bo = Get(name);
            if (!bo) { // Panic
               std::cerr << "Error: no attribute `" << name.c_str() << "' in collection." << std::endl;
               Exit(FAILURE);
            }
            return bo->Type();
         }
         
         std::list< std::string > List() const {
            std::list< std::string > l;
            std::map< std::string, BundledObject * >::const_iterator i;
            
            for (i = _objs.begin(); i != _objs.end(); ++i) {
               l.push_back(i->first);
            }
            return l;
         }
   
         Errc LoadAttributes( FILE * /*file*/ ) {
            return SUCCESS;
         }
   
         Errc SaveAttributes( FILE *file ) const {
            Long attr = _objs.size(); 
            if (Fencode((void*)&attr, sizeof(attr), 1, file) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }

         Errc LoadData( FILE *file );

         Errc SaveData( FILE *file ) const;
   
         Pobject* Mask( const Pobject * /*mask*/ ) {
            return this;
         }

         Pobject* UnMask( const Pobject * /*mask*/, const Pobject * /*reference*/ ) {
            return this;
         }

         void Set( const std::string &name, BundledObject *bo ) {
            std::map< std::string, BundledObject * >::iterator i = _objs.find(name);
            if (i != _objs.end()) {
               delete i->second;
               i->second = bo;
            } else {
               _objs[name] = bo;
            }
         }
         
         BundledObject *Get( const std::string &name ) const {
            std::map< std::string, BundledObject * >::const_iterator i = _objs.find(name);
            return (i != _objs.end()) ? i->second : NULL;
         }
 
         template< typename T >
         void SetValue( const std::string &name, const T &val ) {
            Set(name, new BundledValue< T >(val));
         }
   
         template< typename T >
         T &GetValue( const std::string & name, const T * /*val*/ ) const {
            BundledValue<T>* bvp = dynamic_cast< BundledValue<T>* >(Get(name));
            if (!bvp) { // Panic
               std::cerr << "Error: cannot convert `" << name.c_str() << "' to `" 
                         << TypeName<T>::Name().c_str() << "'." << std::endl;
               Exit(FAILURE);
            }
            return bvp->Value();
         } 
   
         template< typename T >
         void SetArray( const std::string &name, T *val, Long size ) {
            Set(name, new BundledArray< T >(val, size));
         }
   
         template< typename T >
         T* GetArray( const std::string &name, const T * /*val*/ ) const {
            BundledArray<T>* bap = dynamic_cast< BundledArray<T>* >(Get(name));
            if (!bap) { // Panic
               std::cerr << "Error: cannot convert `" << name.c_str() << "' to `Array:" 
                         << TypeName<T>::Name().c_str() << "'." << std::endl;
               Exit(FAILURE);
            }
            return bap->Array();
         } 
   
         template< typename T >
         Long GetArraySize( const std::string &name, const T * /*val*/ ) const {
            BundledArray<T>* bap = dynamic_cast< BundledArray<T>* >(Get(name));
            if (!bap) { // Panic
               std::cerr << "Error: cannot convert `" << name.c_str() << "' to `Array:" 
                         << TypeName<T>::Name().c_str() << "'." << std::endl;
               Exit(FAILURE);
            }
            return bap->NbrElements();
         }
   
         template< typename T >
         void SetPobject( const std::string &name, T *val ) {
            Set(name, new BundledPobject(val));
         }
   
         template< typename T >
         T* GetPobject( const std::string &name, const T * /*val*/ ) const {
            BundledPobject* bap = dynamic_cast< BundledPobject* >(Get(name));
            if (!bap) { // Panic
               std::cerr << "Error: cannot convert `" << name.c_str() << "' to `Pobject:" 
                         << TypeName<T>::Name().c_str() << "'." << std::endl;
               Exit(FAILURE);
            }
            return (T*)bap->Object();
         } 
   
         template< typename T >
         void SetPArray( const std::string &name, T *val, Long size ) {
            Set(name, new BundledPArray((Pobject**)val, size));
         }
   
         template< typename T >
         T** GetPArray( const std::string &name, const T * /*val*/ ) const {
            BundledPArray* bap = dynamic_cast< BundledPArray* >(Get(name));
            if (!bap) { // Panic
               std::cerr << "Error: cannot convert `" << name.c_str() << "' to `PArray:" 
                         << TypeName<T>::Name().c_str() << "'." << std::endl;
               Exit(FAILURE);
            }
            return (T**)bap->PArray();
         } 
   
         template< typename T >
         Long GetPArraySize( const std::string &name, const T * /*val*/ ) const {
            BundledPArray* bap = dynamic_cast< BundledPArray* >(Get(name));
            if (!bap) { // Panic
               std::cerr << "Error: cannot convert `" << name.c_str() << "' to `PArray:" 
                         << TypeName<T>::Name().c_str() << "'." << std::endl;
               Exit(FAILURE);
            }
            return bap->NbrElements();
         } 
   
         template< typename T >
         T** GetNArrays( const std::string &name, Long n, Long &min_out, const T * /*val*/ ) const {
            T **tmp = NULL;
            Long nin = MAXLONG;
            Long n_= MAXLONG;

            tmp = new T*[n];
            for (int i = 0; i < n; ++i) {
               std::stringstream name_in;
               name_in << name << "." << i + 1;
               tmp[i] = this->GETARRAY(name_in.str(), T);
               n_ = this->GETARRAYSIZE(name_in.str(), T);
               if (n_ < nin) {
                  nin = n_;
               }
            }
            min_out = nin;
            return tmp;
         }
   
      private :
         std::map< std::string, BundledObject* > _objs;
   };

} //End of pandore:: namespace

#endif // __PCOLLECTIONH__

---

The Pantheon project
Image Team GREYC Laboratory
UMR CNRS 6072 - ENSICAEN - University of Caen, France
This page was last modified on 19 June 2015