---

semantics_delta.cc

Go to the documentation of this file.

// Semantics Delta implementation -*- C++ -*-

// Copyright (C) 2001-2003 Hermann Schichl
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library 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
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#include <semantics_delta.h>
#include <add_algo>

semantics_delta::semantics_delta(
    const std::vector<unsigned int>& __i, const std::vector<uint32_t>& __b)
           : delta_base("change semantics"), indices(__i), new_f_sem(__b)
        { std::pair_sort(indices.begin(), indices.end(), new_f_sem.begin(),
                         new_f_sem.end()); }

bool semantics_delta::search(unsigned int _i,
                          std::vector<unsigned int>::iterator& _xs)
{
  _xs = std::lower_bound(indices.begin(), indices.end(), _i);
  return _xs != indices.end() && *_xs == _i;
}

void semantics_delta::set(const std::vector<unsigned int>& _i,
                                     const std::vector<semantics>& _s)
{
  std::vector<unsigned int>::const_iterator _xi, _ei(_i.end());
  std::vector<semantics>::const_iterator _xs, _es(_s.end());
  for(_xi = _i.begin(), _xs = _s.begin(); _xi != _ei && _xs != _es;
      ++_xi, ++_xs)
    set(*_xi, *_xs);
}

void semantics_delta::set(const std::vector<unsigned int>& _i,
                                     const std::vector<uint32_t>& _s)
{
  indices = _i;
  new_f_sem = _s;
  std::pair_sort(indices.begin(), indices.end(),
                 new_f_sem.begin(), new_f_sem.end());
}

void semantics_delta::set_convex(const std::vector<unsigned int>& _i,
                                            const std::vector<convex_e>& _s)
{
  std::vector<unsigned int>::const_iterator _xi, _ei(_i.end());
  std::vector<convex_e>::const_iterator _xs, _es(_s.end());
  for(_xi = _i.begin(), _xs = _s.begin(); _xi != _ei && _xs != _es;
      ++_xi, ++_xs)
    set_convex(*_xi, *_xs);
}

void semantics_delta::set_activity(const std::vector<unsigned int>& _i,
                                         const std::vector<activity_descr>& _s)
{
  std::vector<unsigned int>::const_iterator _xi, _ei(_i.end());
  std::vector<activity_descr>::const_iterator _xs, _es(_s.end());
  for(_xi = _i.begin(), _xs = _s.begin(); _xi != _ei && _xs != _es;
      ++_xi, ++_xs)
    set_activity(*_xi, *_xs);
}

void semantics_delta::set_separable(
                                            const std::vector<unsigned int>& _i,
                                            const std::vector<tristate>& _s)
{
  std::vector<unsigned int>::const_iterator _xi, _ei(_i.end());
  std::vector<tristate>::const_iterator _xs, _es(_s.end());
  for(_xi = _i.begin(), _xs = _s.begin(); _xi != _ei && _xs != _es;
      ++_xi, ++_xs)
    set_separable(*_xi, *_xs);
}

void semantics_delta::set_integer(
                                            const std::vector<unsigned int>& _i,
                                            const std::vector<bool>& _s)
{
  std::vector<unsigned int>::const_iterator _xi, _ei(_i.end());
  std::vector<bool>::const_iterator _xs, _es(_s.end());
  for(_xi = _i.begin(), _xs = _s.begin(); _xi != _ei && _xs != _es;
      ++_xi, ++_xs)
    set_integer(*_xi, *_xs);
}

void semantics_delta::set_hard(const std::vector<unsigned int>& _i,
                                          const std::vector<bool>& _s)
{
  std::vector<unsigned int>::const_iterator _xi, _ei(_i.end());
  std::vector<bool>::const_iterator _xs, _es(_s.end());
  for(_xi = _i.begin(), _xs = _s.begin(); _xi != _ei && _xs != _es;
      ++_xi, ++_xs)
    set_hard(*_xi, *_xs);
}

void semantics_delta::set_type(const std::vector<unsigned int>& _i,
                                        const std::vector<type_annotation>& _s)
{
  std::vector<unsigned int>::const_iterator _xi, _ei(_i.end());
  std::vector<type_annotation>::const_iterator _xs, _es(_s.end());
  for(_xi = _i.begin(), _xs = _s.begin(); _xi != _ei && _xs != _es;
      ++_xi, ++_xs)
    set_type(*_xi, *_xs);
}

void semantics_delta::set(unsigned int _i, const semantics& s)
{
  std::vector<unsigned int>::iterator _xs;
  if(search(_i, _xs))
    new_f_sem[_xs - indices.begin()] = encode(s);
  else
  {
    new_f_sem.insert(new_f_sem.begin() + (_xs - indices.begin()), encode(s));
    indices.insert(_xs, _i);
  }
}

void semantics_delta::set_convex(unsigned int _i, const convex_e& c)
{
  std::vector<unsigned int>::iterator _xs;
  if(search(_i, _xs))
    new_f_sem[_xs - indices.begin()] =
                        encode_convex(new_f_sem[_xs - indices.begin()], c);
  else
  {
    new_f_sem.insert(new_f_sem.begin() + (_xs - indices.begin()),
                                encode_convex(0, c));
    indices.insert(_xs, _i);
  }
}

void semantics_delta::set_activity(unsigned int _i, const activity_descr& a)
{
  std::vector<unsigned int>::iterator _xs;
  if(search(_i, _xs))
    new_f_sem[_xs - indices.begin()] =
                        encode_activity(new_f_sem[_xs - indices.begin()], a);
  else
  {
    new_f_sem.insert(new_f_sem.begin() + (_xs - indices.begin()),
                                encode_activity(0, a));
    indices.insert(_xs, _i);
  }
}

void semantics_delta::set_separable(unsigned int _i,
                                               const tristate& t)
{
  std::vector<unsigned int>::iterator _xs;
  if(search(_i, _xs))
    new_f_sem[_xs - indices.begin()] =
                        encode_separable(new_f_sem[_xs - indices.begin()], t);
  else
  {
    new_f_sem.insert(new_f_sem.begin() + (_xs - indices.begin()),
                                encode_separable(0, t));
    indices.insert(_xs, _i);
  }
}

void semantics_delta::set_integer(unsigned int _i, bool b)
{
  std::vector<unsigned int>::iterator _xs;
  if(search(_i, _xs))
    new_f_sem[_xs - indices.begin()] =
                        encode_integer(new_f_sem[_xs - indices.begin()], b);
  else
  {
    new_f_sem.insert(new_f_sem.begin() + (_xs - indices.begin()),
                                encode_integer(0, b));
    indices.insert(_xs, _i);
  }
}

void semantics_delta::set_hard(unsigned int _i, bool b)
{
  std::vector<unsigned int>::iterator _xs;
  if(search(_i, _xs))
    new_f_sem[_xs - indices.begin()] =
                        encode_hard(new_f_sem[_xs - indices.begin()], b);
  else
  {
    new_f_sem.insert(new_f_sem.begin() + (_xs - indices.begin()),
                                encode_hard(0, b));
    indices.insert(_xs, _i);
  }
}

void semantics_delta::set_type(unsigned int _i,
                                          const type_annotation& a)
{
  std::vector<unsigned int>::iterator _xs;
  if(search(_i, _xs))
    new_f_sem[_xs - indices.begin()] =
                        encode_type(new_f_sem[_xs - indices.begin()], a);
  else
  {
    new_f_sem.insert(new_f_sem.begin() + (_xs - indices.begin()),
                                encode_type(0, a));
    indices.insert(_xs, _i);
  }
}

bool semantics_delta::apply(work_node& _x, undelta_base*& _u) const
{
  std::vector<uint32_t> _vs;
  model* __mod = _x.get_model_ptr();
  std::vector<uint32_t>::const_iterator _xs, _es(new_f_sem.end());

  if(indices.empty())
  {
    unsigned int n(__mod->number_of_nodes()), i;
    _vs.reserve(n);
    for(i = 0, _xs = new_f_sem.begin(); i < n && _xs != _es; ++i, ++_xs)
    {
      _vs.push_back(encode(__mod->node(i)->sem));
      decode(*_xs, __mod->node(i)->sem);
    }
  }
  else
  {
    std::vector<unsigned int>::const_iterator _c;
    _vs.reserve(new_f_sem.size());
    for(_c = indices.begin(), _xs = new_f_sem.begin(); _xs != _es; ++_c, ++_xs)
    {
      _vs.push_back(encode(__mod->node(*_c)->sem));
      decode(*_xs, __mod->node(*_c)->sem);
    }
  }
  _u = (undelta_base *) new semantics_undelta(indices, _vs);
  return true;
}

bool semantics_undelta::unapply(work_node& _x) const
{
  model* __mod = _x.get_model_ptr();
  std::vector<uint32_t>::const_iterator _xs, _es(old_f_sem.end());

  if(indices.empty())
  {
    unsigned int n(__mod->number_of_nodes()), i;
    for(i = 0, _xs = old_f_sem.begin(); i < n && _xs != _es; ++i, ++_xs)
      ((semantics_delta*)this)->decode(*_xs, __mod->node(i)->sem);
  }
  else
  {
    std::vector<unsigned int>::const_iterator _c;
    for(_c = indices.begin(), _xs = old_f_sem.begin(); _xs != _es; ++_c, ++_xs)
      ((semantics_delta*)this)->decode(*_xs, __mod->node(*_c)->sem);
  }
  return true;
}

---