Array.hpp

Go to the documentation of this file.

/*
 * $Id: Array.hpp 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.
 */

#ifndef IPO_ARRAY_HPP
#define IPO_ARRAY_HPP

#include<vector>
#include<algorithm>
#include<ccgsl/vector.hpp>
#include"Variable.hpp"

namespace ipo {

  class Array : public detail::Var {
  public:
    typedef std::vector<Variable>::value_type value_type;
    typedef std::vector<Variable>::allocator_type allocator_type;
    typedef std::vector<Variable>::size_type size_type;
    typedef std::vector<Variable>::difference_type difference_type;
    typedef std::vector<Variable>::reference reference;
    typedef std::vector<Variable>::const_reference const_reference;
    typedef std::vector<Variable>::pointer pointer;
    typedef std::vector<Variable>::const_pointer const_pointer;
    typedef std::vector<Variable>::iterator iterator;
    typedef std::vector<Variable>::const_iterator const_iterator;
    typedef std::vector<Variable>::reverse_iterator reverse_iterator;
    typedef std::vector<Variable>::const_reverse_iterator const_reverse_iterator;
    Array( detail::ModelBase& model, allocator_type const& alloc = allocator_type(),
       char const* const name = nullptr );
    Array( detail::ModelBase& model, std::string const& name );
    Array( detail::ModelBase& model, size_t const size, char const* const name = nullptr );
    Array( detail::ModelBase& model, size_t const size, std::string const& name );
    Array( detail::ModelBase& model, size_t const size, value_type const& val,
       allocator_type const& alloc, std::string const& name );
    Array( detail::ModelBase& model, size_t const size, value_type const& val,
       allocator_type const& alloc = allocator_type(), char const* const name = 0 );
    Array( detail::ModelBase& model, size_t const size, value_type const& val,
       std::string const& name );
    Array( detail::ModelBase& model, size_t const size, value_type const& val,
       char const * const name );
    Array( Array const& array );
    Array( Array const& array, allocator_type const& alloc );
    Array( Array&& array ) : Var { model }, dataArray { std::move( array.dataArray ) }{}
    Array( detail::ModelBase& model, std::initializer_list<Variable> init,
       std::vector<Variable>::allocator_type const& alloc
       = std::vector<Variable>::allocator_type(),
       char const* const name = 0 );
    Array( detail::ModelBase& model, std::initializer_list<Variable> init,
       std::vector<Variable>::allocator_type const& alloc,
       std::string const& name );
    Array( detail::ModelBase& model, std::initializer_list<Variable> init,
       char const* const name = 0 );
    Array( detail::ModelBase& model, std::initializer_list<Variable> init,
       std::string const& name );
    Array& operator=( Array&& array );
    Array& operator=( Array& array );
    std::string getName() const;
    void setName( std::string const& name );
    void setName( char* const name );
    // container concept/vector stuff
    void assign( size_type count, value_type const& value );
    template<typename InputIterator>
    void assign( InputIterator first, InputIterator last ){
      dataArray->array.assign( first, last );
      if( not dataArray->testModelMatch( *getModel() ) )
    throw IPOE( "iop::Array::assign: at least one variable discarded because it is "
            "not owned by model that owns array." );
      model.notify();
    }
    void assign( std::initializer_list<Variable> init );
    allocator_type get_allocator() const { return dataArray->array.get_allocator(); }
    reference at( size_type pos ){ model.notify(); return dataArray->array.at( pos ); }
    const_reference at( size_type pos ) const { return dataArray->array.at( pos ); }
    reference operator[]( size_type pos ){ model.notify(); return dataArray->array[pos]; }
    const_reference operator[]( size_type pos ) const { return dataArray->array[pos]; }
    reference front(){ model.notify(); return dataArray->array.front(); }
    const_reference front() const { return dataArray->array.front(); }
    reference back(){ model.notify(); return dataArray->array.back(); }
    const_reference back() const { return dataArray->array.back(); }
    pointer data(){ model.notify(); return dataArray->array.data(); }
    const_pointer data() const { return dataArray->array.data(); }
    iterator begin(){ model.notify(); return dataArray->array.begin(); }
    const_iterator begin() const { return dataArray->array.begin(); }
    const_iterator cbegin() const { model.notify(); return dataArray->array.cbegin(); }
    iterator end(){ model.notify(); return dataArray->array.end(); }
    const_iterator end() const { return dataArray->array.end(); }
    const_iterator cend() const { model.notify(); return dataArray->array.cend(); }
    reverse_iterator rbegin(){ model.notify(); return dataArray->array.rbegin(); }
    const_reverse_iterator rbegin() const { return dataArray->array.rbegin(); }
    const_reverse_iterator crbegin() const { return dataArray->array.crbegin(); }
    reverse_iterator rend(){ model.notify(); return dataArray->array.rend(); }
    const_reverse_iterator rend() const { return dataArray->array.rend(); }
    const_reverse_iterator crend() const { return dataArray->array.crend(); }
    bool empty() const { return dataArray->array.empty(); }
    size_type size() const { return dataArray->array.size(); }
    size_type max_size() const { return dataArray->array.max_size(); }
    void reserve( size_type size ){ dataArray->array.reserve( size ); }
    size_type capacity() const { return dataArray->array.capacity(); }
    void shrink_to_fit(){ dataArray->array.shrink_to_fit(); }
    void clear(){ dataArray->array.clear(); model.notify(); }
    iterator insert( iterator pos, value_type const& value );
    iterator insert( iterator pos, value_type&& value );
    void insert( iterator pos, size_type count, const value_type& value );
    template<typename InputIterator>
    void insert( iterator pos, InputIterator first, InputIterator last ){
      dataArray->array.insert( pos, first, last );
      if( not dataArray->testModelMatch( *getModel() ) )
    throw IPOE( "iop::Array::insert: at least one variable discarded because it is "
            "not owned by model that owns array." );
      model.notify();
    }
    void insert( iterator pos, std::initializer_list<Variable> ilist );
    template<class... Args>
    iterator emplace( const_iterator pos, Args&&... args ){
      model.notify(); 
      iterator i = dataArray->array.emplace( pos, args... );
      if( i->getModel() != getModel() ){
    dataArray->array.erase( i );
    throw IPOE( "iop::Array::emplace: variable not inserted because it is "
            "not owned by model that owns array." );
      }
      return i;
    }
    iterator erase( iterator pos ){ model.notify(); return dataArray->array.erase( pos ); }
    iterator erase( iterator first, iterator last ){
      model.notify(); return dataArray->array.erase( first, last ); }
    void push_back( value_type const& value );
    void push_back( value_type&& value );
    template<typename... Args>
    void emplace_back( Args&&... args ){
      dataArray->array.emplace_back( args... );
      if( back().getModel() != getModel() ){
    dataArray->array.erase( --dataArray->array.end() );
    throw IPOE( "iop::Array::emplace: variable not inserted because it is "
            "not owned by model that owns array." );
      }
      model.notify();
    }
    void pop_back(){ dataArray->array.pop_back(); model.notify(); }
    void resize( size_type count ){ dataArray->array.resize( count, Variable { model } );
      model.notify(); }
    void resize( size_type count, const value_type& value);
    void swap( Array& array );
    bool contains( Variable const& variable ) const;
    void setValue( gsl::vector const& vector );
    gsl::vector getValue() const;
    virtual void summary( std::ostream& ostream = std::cout,
              std::string const& prefix = "" ) const override;
  private:
    struct Data {
      Data( detail::ModelBase& model, std::vector<Variable>::allocator_type alloc,
        std::string const& name );
      Data( detail::ModelBase& model, size_t const size, std::string const name );
      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 );
      Data( detail::ModelBase& model, Data const& dataArray );
      Data( detail::ModelBase& model, Data const& dataArray,
        std::vector<Variable>::allocator_type const& alloc );
      Data( Data&& dataArray ) : name { std::move( dataArray.name ) },
    array { std::move( dataArray.array ) }{}
      Data( detail::ModelBase& model, std::initializer_list<Variable> init,
        std::vector<Variable>::allocator_type const& alloc
        = std::vector<Variable>::allocator_type(),
        char const* const name = 0 );
      Data( detail::ModelBase& model, std::initializer_list<Variable> init,
        std::vector<Variable>::allocator_type const& alloc,
        std::string const name );
      Data( detail::ModelBase& model, std::initializer_list<Variable> init,
        char const* const name = 0 );
      Data( detail::ModelBase& model, std::initializer_list<Variable> init,
        std::string const& name );
      bool testModelMatch( detail::ModelBase const& model );
      std::string name;
      std::vector<Variable> array;
    };
    std::shared_ptr<Data> dataArray;
    // friend declarations
    friend bool ipo::operator==( Array const&, Array const& );
    friend bool ipo::operator!=( Array const&, Array const& );
    friend bool ipo::operator<( Array const&, Array const& );
    friend bool ipo::operator<=( Array const&, Array const& );
    friend bool ipo::operator>( Array const&, Array const& );
    friend bool ipo::operator>=( Array const&, Array const& );
  };
  
  inline bool operator==( Array const& lhs, Array const& rhs ){
    return lhs.dataArray->array == rhs.dataArray->array; }
  inline bool operator!=( Array const& lhs, Array const& rhs ){
    return lhs.dataArray->array != rhs.dataArray->array; }
  inline bool operator<( Array const& lhs, Array const& rhs ){
    return lhs.dataArray->array < rhs.dataArray->array; }
  inline bool operator<=( Array const& lhs, Array const& rhs ){
    return lhs.dataArray->array <= rhs.dataArray->array; }
  inline bool operator>( Array const& lhs, Array const& rhs ){
    return lhs.dataArray->array > rhs.dataArray->array; }
  inline bool operator>=( Array const& lhs, Array const& rhs ){
    return lhs.dataArray->array >= rhs.dataArray->array; }
  
  inline void swap( Array& first, Array& second ){
    first.swap( second ); }

}

#endif