Array.cc

Go to the documentation of this file.

/*
 * $Id: Array.cc 187 2014-10-22 09:25:23Z jdl3 $
 * Copyright (C) 2013, 2014 John D Lamb
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 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
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifdef HAVE_CONFIG_H
#  include<config.h>
#endif

#include"Array.hpp"

using namespace ipo;

Array::Data::Data( detail::ModelBase& model, std::vector<Variable>::allocator_type alloc,
           std::string const& name )
  : name { name }, array { alloc }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Data::Data( detail::ModelBase& model, size_t size, std::string const name )
  : name { name }, array { size, Variable { model } }
{
  // Recreate and rename variables
  for( size_t i { 0 }; i < size; ++i ){
    array[i] = Variable { model };
    array[i].setName( name + format::subscript( i ) );
  }
  model.notify();
}

Array::Data::Data( detail::ModelBase& model, size_t const size,
           std::vector<Variable>::value_type const& val,
           std::vector<Variable>::allocator_type alloc, std::string const& name )
  : name { name }, array { size, val, alloc }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Data::Data( detail::ModelBase& model, Data const& dataArray )
  : name { dataArray.name }, array { dataArray.array }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Data::Data( detail::ModelBase& model, Data const& dataArray,
           std::vector<Variable>::allocator_type const& alloc )
  : name { dataArray.name }, array { dataArray.array, alloc }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Data::Data( detail::ModelBase& model, std::initializer_list<Variable> init,
           std::vector<Variable>::allocator_type const& alloc,
           char const* const name )
  : name { nullptr == name ? std::string() : std::string { name } }, array { init, alloc }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Data::Data( detail::ModelBase& model, std::initializer_list<Variable> init,
           std::vector<Variable>::allocator_type const& alloc,
           std::string const name )
  : name { name }, array { init, alloc }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Data::Data( detail::ModelBase& model, std::initializer_list<Variable> init,
           char const* const name )
  : name { nullptr == name ? std::string() : std::string { name } }, array { init }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Data::Data( detail::ModelBase& model, std::initializer_list<Variable> init,
           std::string const& name )
  : name { name }, array { init }
{
  if( not testModelMatch( model ) )
    throw IPOE( "ipo::Array::Data::Data: at least one variable discarded because it is "
        "not owned by model that owns array." );
}

Array::Array( detail::ModelBase& model, allocator_type const& alloc, char const* const name )
  : Array { model, 0, nullptr == name ? std::string {} : std::string { name } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, std::string const& name )
  : Var { model },
  dataArray { std::shared_ptr<Data> { new Data { model, static_cast<size_t>( 0 ), name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, size_t const size, char const* const name )
  : Array { model, size, nullptr == name ? std::string {} : std::string { name } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, size_t const size, std::string const& name )
  : Var { model }, dataArray { std::shared_ptr<Data> { new Data { model, size, name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, size_t const size, value_type const& val,
          allocator_type const& alloc, std::string const& name )
  : Var { model },
  dataArray { std::shared_ptr<Data> { new Data { model, size, val, alloc, name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, size_t const size, value_type const& val,
          allocator_type const& alloc, char const* const name )
  : Var { model },
  dataArray { std::shared_ptr<Data> { new Data { model, size, val, alloc, name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, size_t const size, value_type const& val,
          std::string const& name )
  : Var { model },
  dataArray { std::shared_ptr<Data> { new Data { model, size, val, allocator_type{}, name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, size_t const size, value_type const& val,
          char const * const name )
  : Var { model },
  dataArray { std::shared_ptr<Data> { new Data { model, size, val, allocator_type{}, name } } }
{
  model.notify();
}

Array::Array( Array const& array )
  : Var { array.model },
  dataArray { std::shared_ptr<Data> { new Data { model, *array.dataArray } } }
{
  model.notify();
}

Array::Array( Array const& array, allocator_type const& alloc )
  : Var { array.model },
  dataArray { std::shared_ptr<Data> { new Data { model, *array.dataArray, alloc } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, std::initializer_list<Variable> init,
          std::vector<Variable>::allocator_type const& alloc,
          char const* const name )
  : Var { model },
  dataArray { std::shared_ptr<Data> { new Data { model, init, alloc, name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, std::initializer_list<Variable> init,
          std::vector<Variable>::allocator_type const& alloc,
          std::string const& name )
  : Var { model },
  dataArray { std::shared_ptr<Data> { new Data { model, init, alloc, name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, std::initializer_list<Variable> init,
          char const* const name )
  : Var { model }, dataArray { std::shared_ptr<Data> { new Data { model, init, name } } }
{
  model.notify();
}

Array::Array( detail::ModelBase& model, std::initializer_list<Variable> init,
          std::string const& name )
  : Var { model }, dataArray { std::shared_ptr<Data> { new Data { model, init, name } } }
{
  model.notify();
}

std::string
Array::getName() const{
  return dataArray->name;
}

void
Array::setName( std::string const& name ){
  dataArray->name = name;
}

void
Array::setName( char* const name ){
  dataArray->name = nullptr == name ? std::string() : name;
}

void
Array::swap( Array& array ){
  if( getModel() != array.getModel() )
    throw IPOE( "ipo::Array::swap: arrays not swapped because they are "
        "owned by different models." );
  std::swap( array.dataArray, dataArray );
  model.notify();
}

Array&
Array::operator=( Array&& array ){
  if( &array.model != &model )
    throw IPOE( "ipo::Array::operator=(): cannot assign array to different model." );
  std::swap( dataArray, array.dataArray );
  return *this;
}

Array&
Array::operator=( Array& array ){
  if( &array.model != &model )
    throw IPOE( "ipo::Array::operator=(): cannot assign array to different model." );
  dataArray = array.dataArray;
  return *this;
}

bool
Array::Data::testModelMatch( detail::ModelBase const& model ){
  bool result { true };
  auto p = array.begin();
  while( p != array.end() )
    if( p->getModel() != &model ){
      p = array.erase( p );
      result = false;
    } else ++p;
  return result;
}

void
Array::assign( size_type count, value_type const& value ){
  if( value.getModel() != getModel() )
    throw IPOE( "ipo::Array::assign: variable not assigned because it is "
        "not owned by model that owns array." );
  dataArray->array.assign( count, value );
  model.notify();
}

void
Array::assign( std::initializer_list<Variable> init ){
  dataArray->array.assign( init );
  if( not dataArray->testModelMatch( *getModel() ) )
    throw IPOE( "ipo::Array::assign: at least one variable discarded because it is "
        "not owned by model that owns array." );
  model.notify(); 
}

Array::iterator
Array::insert( iterator pos, const value_type& value ){
  if( value.getModel() != getModel() )
    throw IPOE( "ipo::Array::insert: variable not inserted because it is "
        "not owned by model that owns array." );
  model.notify();
  return dataArray->array.insert( pos, value );
}

Array::iterator
Array::insert( iterator pos, value_type&& value ){
  if( value.getModel() != getModel() )
    throw IPOE( "ipo::Array::insert: variable not inserted because it is "
        "not owned by model that owns array." );
  model.notify(); 
  return dataArray->array.insert( pos, value );
}

void
Array::insert( iterator pos, size_type count, const value_type& value ){
  if( value.getModel() != getModel() )
    throw IPOE( "ipo::Array::insert: variable not inserted because it is "
        "not owned by model that owns array." );
  dataArray->array.insert( pos, count, value );
  model.notify(); 
}

void
Array::insert( iterator pos, std::initializer_list<Variable> ilist ){
  dataArray->array.insert( pos, ilist );
  if( not dataArray->testModelMatch( *getModel() ) )
    throw IPOE( "ipo::Array::insert: at least one variable discarded because it is "
        "not owned by model that owns array." );
  model.notify(); 
}

void
Array::push_back( value_type const& value ){
  if( value.getModel() != getModel() )
    throw IPOE( "ipo::Array::push_back: variable not inserted because it is "
        "not owned by model that owns array." );
  dataArray->array.push_back( value );
  model.notify();
}

void
Array::push_back( value_type&& value ) {
  if( value.getModel() != getModel() )
    throw IPOE( "ipo::Array::push_back: variable not inserted because it is "
        "not owned by model that owns array." );
  dataArray->array.push_back( value );
  model.notify();
}

void
Array::resize( size_type count, const value_type& value){
  if( count > dataArray->array.size() and value.getModel() != getModel() )
    throw IPOE( "ipo::Array::resize: array not resized because new values would"
        "not be owned by model that owns array." );
  dataArray->array.resize( count, value );
  model.notify();
}

bool
Array::contains( Variable const& variable ) const {
  return std::find( begin(), end(), variable ) != end();
}

void
Array::setValue( gsl::vector const& vector ){
  size_t const sizeV { vector.size() };
  if( sizeV != size() )
    throw IPOE( "ipo::Array::setValue(): " 
        "sizes of vector and array do not match." );
  for( size_t i { 0 }; i < sizeV; ++i ) (*this)[i].setValue( vector[i] );
}

gsl::vector
Array::getValue() const {
  size_t const sizeA { size() };
  gsl::vector vector( sizeA );
  for( size_t i { 0 }; i < sizeA; ++i ) vector[i] = (*this)[i].getValue();
  return vector;
}

void
Array::summary( std::ostream& ostream, std::string const& prefix ) const {
  ostream << prefix << getName() << ":" << std::endl;
  for( auto const& e : *this ){
    ostream << prefix;
    e.summary( ostream, prefix );
  }
}