/// extraction of data from the wrapped object, returned memory is a copy, not a view
 /// if nullptr is passed (also default parameter), memory is allocated.
 /// @return pointer to the newly allocated data which is of size size_of()*stride()*size()
 virtual const void* pack(void* buf=nullptr) const
 {
   if ( is_null(m_data) ) throw cf3::common::BadPointer(FromHere(),name()+": Data expired.");
   if (buf==nullptr) buf=new T[m_data->num_elements()*m_stride+1];
   if ( buf == nullptr ) throw cf3::common::NotEnoughMemory(FromHere(),name()+": Could not allocate temporary buffer.");
   T* ibuf=(T*)buf;
   for (int i=0; i<(const int)(m_data->num_elements()*m_stride); i++)
     *ibuf++=(*m_data)[i];
   return buf;
 }

CLink& CLink::link_to ( Component::Ptr lnkto )
{
  if ( is_null(lnkto) )
    throw BadValue(FromHere(), "Cannot link to null component");

  if (lnkto->is_link())
    throw SetupError(FromHere(), "Cannot link a CLink to another CLink");

  m_link_component = lnkto;
  return *this;
}

void NLink::go_to_target(SignalArgs & )
{
  if ( is_null(m_target) )
    throw ValueNotFound (FromHere(), "Target of this link is not set or not valid");

  QModelIndex index = NTree::global()->index_from_path(m_target->uri());

  if(index.isValid())
    NTree::global()->set_current_index(index);
  else
    throw ValueNotFound (FromHere(), m_target->uri().string() + ": path does not exist");
}

RealVector ElementType::plane_jacobian_normal(const RealVector& mapped_coords,
                                              const RealMatrix& nodes,
                                              const CoordRef direction) const
{
  throw Common::NotImplemented(FromHere(),"jacobian not implemented for "+derived_type_name());
  return RealVector(1);
}

 inline void operator()(boost::any& to_set, const boost::any& new_value)
 {
   if(new_value.type() == to_set.type())
   {
     to_set = new_value;
   }
   else
   {
     try
     {
       std::vector<Uint> int_vals = boost::any_cast< std::vector<Uint> >(new_value);
       const Uint nb_vals = int_vals.size();
       std::vector<int> result(nb_vals);
       for(Uint i = 0; i != nb_vals; ++i)
       {
         result[i] = static_cast<int>(int_vals[i]);
       }
       to_set = result;
     }
     catch(boost::bad_any_cast& e)
     {
       throw CastingFailed(FromHere(), std::string("Failed to cast object of type ") + new_value.type().name() + " to type std::vector<int>");
     }
   }
 }

TreeView::TreeView(CentralPanel * optionsPanel, QMainWindow * parent,
                   bool contextMenuAllowed)
: QTreeView(parent),
  m_context_menu_allowed(contextMenuAllowed)
{
  if(m_context_menu_allowed && optionsPanel == nullptr)
    throw BadValue(FromHere(), "Options panel is a nullptr pointer");

  // instantiate class attributes
  m_model_filter = new FilteringModel(this);
  m_central_panel = optionsPanel;
  m_signal_manager = new SignalManager(parent);

  m_model_filter->setSourceModel(NTree::global().get());
  m_model_filter->setDynamicSortFilter(true);

  this->setModel(m_model_filter);

  this->set_read_only(false);

  // when right clicking on the Client,
  // a "Context menu event" must be generated
  this->setContextMenuPolicy(Qt::CustomContextMenu);

  this->header()->setResizeMode(QHeaderView::ResizeToContents);
  this->header()->setStretchLastSection(true);

  if(m_context_menu_allowed)
  {
    connect(NTree::global().get(),
            SIGNAL(current_index_changed(QModelIndex, QModelIndex)),
            this,
            SLOT(current_index_changed(QModelIndex, QModelIndex)));
  }
}

  Common_API bool from_str<bool> (const std::string& str)
  {
    bool match = false;
    boost::algorithm::is_equal test_equal;

    if ( test_equal(str,"true") ||
         test_equal(str,"True") ||
         test_equal(str,"on")   ||
         test_equal(str,"1")     )
    {
      return true;
    }

    if ( test_equal(str,"false") ||
         test_equal(str,"False") ||
         test_equal(str,"off")   ||
         test_equal(str,"0")      )
    {
      return false;
    }

    if (!match)
      throw ParsingFailed (FromHere(), "Incorrect option conversion to bool of string [" + str + "]" );
    return true;
  }

const CF::Mesh::ElementType& Triag2DLagrangeP2B::face_type(const CF::Uint face) const
{
  throw Common::NotImplemented( FromHere(), "Line2DLagrangeP2 does not exist yet" );

  static const Line2DLagrangeP1 facetype;
  return facetype;
}

 /// setup of passing by reference
 /// @param std::vector of data
 /// @param stride number of array element grouping
 void setup(boost::multi_array<T,1>& data, const bool needs_update)
 {
   if (boost::is_pod<T>::value==false) throw cf3::common::BadValue(FromHere(),name()+": Data is not POD (plain old datatype).");
   m_data=&data;
   m_stride = 1;
   m_needs_update=needs_update;
 }

 /// returning back values into the data wrapped by objectwrapper
 /// @param pointer to the data to be committed back
 virtual void unpack(void* buf) const
 {
   if ( is_null(m_data) ) throw cf3::common::BadPointer(FromHere(),name()+": Data expired.");
   T* ibuf=(T*)buf;
   for (int i=0; i<(const int)(m_data->num_elements()*m_stride); i++)
     (*m_data)[i]=*ibuf++;
 }

  /// Create ElementCache if non-existant, else get the ElementCache and lock it through ElementCacheHandle constructor
  ElementCacheT& cache(const Handle<mesh::Entities const>& entities, const Uint elem)
  {
    typename value_type::iterator it = m_element_caches.find(entities.get());
    if(it != m_element_caches.end())
    {
      m_cache=it->second.get();

      if ( get().idx == elem ) // Nothing to be done
      {
        get().lock();
        return get();
      }

      if (get().locked()) throw common::IllegalCall(FromHere(),"cache "+uri().string()+" is locked to elem "+common::to_str(it->second->idx));

      set_cache(elem);
      return get();
    }
    boost::shared_ptr<ElementCacheT> element_cache ( new ElementCacheT );
    m_cache=element_cache.get();
    m_cache->cache = this->handle<Cache>();
    configure_cache(entities);
    set_cache(elem);
    m_element_caches[entities.get()]=element_cache;
    return get();
  }

double DerivativesType5::a2(Data::DataStorage& data_Q, Data::DataStorage& data_W, Data::DataStorage& data_MIX,  Data::DataStorage& dp, CHEM::SpeciesSet& species_set, int ND)
{
	double rho = data_MIX(0);

	double a2_rho = 0.0;

	for (int s= 0; s <= species_set.NS-1; s++)
	{
		a2_rho	+= data_Q(s)*dp(s);
	}

	for (int k = species_set.NS; k <= species_set.NS+ND-1; k++)
	{
		a2_rho += data_Q(k)*dp(k);
	}

	a2_rho	+= (data_Q(species_set.NS+ND) + data_W(species_set.NS+ND)) * dp(species_set.NS+ND);
	a2_rho	+= data_Q(species_set.NS+ND+1) * dp(species_set.NS+ND+1);

	if (a2_rho < 0.0 || a2_rho == std::numeric_limits<double>::infinity() || a2_rho != a2_rho)
	{
		throw Common::ExceptionNegativeValue (FromHere(), "Negative value of a2: Need to check dp_dQ.");
	}

	//Common::ErrorCheckNonNegative<double>(a2_rho, "DerivativesType5: rho_a2 cannot be negative");
	return (a2_rho / rho);
}

void CPlotXY::convergence_history( SignalArgs & args )
{
  if( is_not_null(m_data.get()) )
  {
    SignalFrame reply = args.create_reply( uri() );
    SignalFrame& options = reply.map( Protocol::Tags::key_options() );
//    std::vector<Real> data(8000);
    CTable<Real>& table = *m_data.get();
    std::vector<std::string> labels =
        list_of<std::string>("x")("y")("z")("u")("v")("w")("p")("t");

    add_multi_array_in(options.main_map, "Table", m_data->array(), ";", labels);

//    for(Uint row = 0 ; row < 1000 ; ++row)
//    {
//      for(Uint col = 0 ; col < 8 ; ++col)
//        data[ (row * 8) + col ] = table[row][col];
//    }

//    XmlNode node = options.add("Table", data, " ; ");

//    node.set_attribute("dimensions", "8");
  }
  else
    throw SetupError( FromHere(), "Data to plot not setup" );
}

  /// Return the wrapped component
  ComponentT& component()
  {
    if(is_null(m_component))
      throw common::SetupError(FromHere(), "ComponentWrapperImpl points to a null component");

    return **m_component;
  }

Field& Dictionary::create_field(const std::string &name, math::VariablesDescriptor& variables_descriptor)
{
  CFinfo << "Creating field " << uri()/name << CFendl;
  if (m_dim == 0) throw SetupError(FromHere(), "dimension not configured");
  Handle<Field> field = create_component<Field>(name);
  field->set_dict(*this);
  field->set_descriptor(variables_descriptor);
  if (variables_descriptor.options().option(common::Tags::dimension()).value<Uint>() == 0)
  {
    field->descriptor().options().set(common::Tags::dimension(),m_dim);
  }
  field->set_row_size(field->descriptor().size());
  field->resize(size());

  update_structures();

  CFinfo << "Created field " << field->uri() << " with variables \n";
  for (Uint var=0; var<field->descriptor().nb_vars(); ++var)
  {
    CFinfo << "    - " << field->descriptor().user_variable_name(var) << " [" << field->descriptor().var_length(var) << "]\n";
  }
  CFinfo << CFflush;


  return *field;
}

void Solve3x3eqn(std::vector< std::vector<double> >& A, std::vector<double> &b,  std::vector<double> &x)
{
	if (fabs<double>(b[0]) <= MATH_ZERO	&& fabs<double>(b[1]) <= MATH_ZERO && fabs<double>(b[2]) <= MATH_ZERO)
	{
		x.resize(3, 0.0);
	}
	else
	{
		x.resize(3, 0.0);
		double det = A[0][0]*(A[1][1]*A[2][2] - A[1][2]*A[2][1]) - A[0][1]*(A[1][0]*A[2][2] - A[1][2]*A[2][1]) + A[0][2]*(A[1][0]*A[2][1] - A[1][1]*A[2][0]);

		if( fabs<double>(det) < MATH_ZERO) throw Common::ExceptionDimensionMatch (FromHere(), "NO Solution (zero determinent)");

		double a11 = A[1][1]*A[2][2] - A[1][2]*A[2][1];
		double a12 = -(A[1][0]*A[2][2] - A[1][2]*A[2][0]);
		double a13 = A[1][0]*A[2][1] - A[1][1]*A[2][0];

		double a21 =-(A[0][1]*A[2][2] - A[0][2]*A[2][1]);
		double a22 = A[0][0]*A[2][2] - A[0][2]*A[2][0];
		double a23 =-(A[0][0]*A[2][1] - A[0][1]*A[2][0]);

		double a31 = A[2][1]*A[1][2] - A[0][2]*A[1][1];
		double a32 =-(A[0][0]*A[1][2] - A[0][2]*A[1][0]);
		double a33 = A[0][0]*A[1][1] - A[0][1]*A[1][0];

		x[0] =  (a11*b[0] + a12*b[1] + a13*b[2])/det;
		x[1] =  (a21*b[0] + a22*b[1] + a23*b[2])/det;
		x[2] =  (a31*b[0] + a32*b[1] + a33*b[2])/det;
	}
}

 Real solve_yplus(FunctorT&& f)
 {
   Real yp_low = 0.;
   Real yp_high = 1000.;
   Uint count = 1;
   Real yplus = 0.;
   while(((yp_high-yp_low) > 1e-4) && count < 1000)
   {
     yplus = (yp_low+yp_high)/2.;
     if (f(yplus) < yplus)
     {
       yp_high = yplus;
     }
     else
     {
       yp_low = yplus;
     }
     count += 1;
   }
   if(count == 1000)
   {
     throw common::FailedToConverge(FromHere(), "y+ computation did not converge");
   }
   return yplus;
 }

Uint CField::var_number ( const std::string& vname ) const
{
  const std::vector<std::string>::const_iterator var_loc_it = std::find(m_var_names.begin(), m_var_names.end(), vname);
  if(var_loc_it == m_var_names.end())
    throw Common::ValueNotFound(FromHere(), "Variable " + vname + " was not found in field " + name());
  return var_loc_it - m_var_names.begin();
}

    typename LIB::Ptr library ()
    {
      const std::string lname = LIB::library_namespace(); //instead of LIB::type_name();
      Component::Ptr clib = get_child_ptr(lname);

      typename LIB::Ptr lib;
      if ( is_null(clib) ) // doesnt exist so build it
      {
        CF::Common::TypeInfo::instance().regist< LIB >( lname );
        lib = create_component_ptr< LIB >(lname);
        cf_assert( is_not_null(lib) );
        return lib;
      }

      // try to convert existing ptr to LIB::Ptr and return it
      lib = clib->as_ptr<LIB>();

      if( is_null(lib) ) // conversion failed
        throw CastingFailed( FromHere(),
                            "Found component in CLibraries with name "
                            + lname
                            + " but is not the actual library "
                            + LIB::type_name() );
      return lib;
    }

  void read_data_block(char *data, const Uint count, const Uint block_idx)
  {
    static const std::string block_prefix("__CFDATA_BEGIN");
    
    XmlNode block_node = get_block_node(block_idx);
      
    const Uint block_begin = from_str<Uint>(block_node.attribute_value("begin"));
    const Uint block_end = from_str<Uint>(block_node.attribute_value("end"));
    const Uint compressed_size = block_end - block_begin - block_prefix.size();

    // Check the prefix
    binary_file.seekg(block_begin);
    std::vector<char> prefix_buf(block_prefix.size());
    binary_file.read(&prefix_buf[0], block_prefix.size());
    const std::string read_prefix(prefix_buf.begin(), prefix_buf.end());
    if(read_prefix != block_prefix)
      throw SetupError(FromHere(), "Bad block prefix for block " + to_str(block_idx));
   
    if(count != 0)
    {
      // Build a decompressing stream
      boost::iostreams::filtering_istream decompressing_stream;
      decompressing_stream.set_auto_close(false);
      decompressing_stream.push(boost::iostreams::zlib_decompressor());
      decompressing_stream.push(boost::iostreams::restrict(binary_file, 0, compressed_size));
      
      // Read the data
      decompressing_stream.read(data, count);
      decompressing_stream.pop();
    }
    
    cf3_assert(binary_file.tellg() == block_end);
  }