sarray.cxx

Go to the documentation of this file.

//    sampalib.org ESL library and tools
//    Copyright (C) 2007  Thierry Grellier
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License version 2 as
//    published by the Free Software Foundation.
//
//    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 General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//    contact: www.sampalib.org

#include <cassert>
#include "sampa/core/sarray.h"
#include "sampa/core/persistence.cxx"
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_fundamental.hpp>

namespace Sampa {

enum InitMode {
  INIT_OBJECT,
  INIT_DEFAULT_CTR,
  INIT_FUNDAMENTAL
};

template<InitMode, typename Element>
struct InitElements;

template<typename Element>
struct InitElements<INIT_OBJECT, Element> {
  void operator()(Element* elements, size_t capacity, const char* name) {
    char idxname[std::strlen(name)+sizeof("[012345]")+1];
    for (size_t i = 0; i != capacity; i++) { 
      sprintf(idxname, "%s[%ld]", name, i+1);
      Element* initialized = new(&elements[i]) Element(StringParameter(idxname, idxname).get_value()); 
      assert(initialized == &elements[i]);
    }
  }
};

template<typename Element>
struct InitElements<INIT_DEFAULT_CTR, Element> {
  void operator()(Element* elements, size_t capacity, const char*) {
    for (size_t i = 0; i != capacity; i++) { 
      Element* initialized = new(&elements[i]) Element(DEFAULT_CTR); 
      assert(initialized == &elements[i]);
    }
  }
};

template<typename Element>
struct InitElements<INIT_FUNDAMENTAL, Element> {
  void operator()(Element*, size_t, const char*) {}
};

template<typename Element>
Array<Element>::Array(size_t capacity, const char* name)
{
#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
  m_elements = array_of_scalar<Element>::create(*get_storage(), capacity);
#else
  m_elements = new Element[capacity];
#endif
  Element* p = begin();
  InitElements<   boost::is_base_of<Object, Element>::value ? INIT_OBJECT
               : (boost::is_fundamental<Element>::value     ? INIT_FUNDAMENTAL
                                                            : INIT_DEFAULT_CTR), Element> init;
  init(p, capacity, name);
}

template<typename Element>
Array<Element>::~Array() 
{
#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
  delete   m_elements;
#else
  delete[] m_elements;
#endif
}
 
}

#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
#  define SAMPA_MAKE_ARRAY(class_name) \
    REGISTER_TEMPLATE(array_of_scalar<class_name >); \
    namespace Sampa { \
      SAMPA_MAKE_TMPL_PERSISTENT(Array<class_name>, Array, REF(m_elements)); \
      template class Array<class_name>; \
    }
#else
#  define SAMPA_MAKE_ARRAY(class_name) \
    namespace Sampa { \
      SAMPA_MAKE_TMPL_PERSISTENT(Array<class_name>, Array, REF(m_elements)); \
      template class Array<class_name>; \
    }
#endif

#define SAMPA_MAKE_PTRQUEUE(class_name) \
  namespace Sampa { \
    SAMPA_MAKE_TMPL_PERSISTENT(PtrQueue<class_name >, PtrQueue, NO_REFS); \
    template class PtrQueue<class_name >; \
  }

---