Ichthyostega
cb73ae2d2c
This implements the application of our new list diff language to a target sequence given within a vector. Unit test pass
355 lines
10 KiB
C++
355 lines
10 KiB
C++
/*
|
|
DiffListApplication(Test) - demonstrate linearised representation of list diffs
|
|
|
|
Copyright (C) Lumiera.org
|
|
2014, Hermann Vosseler <Ichthyostega@web.de>
|
|
|
|
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.
|
|
|
|
* *****************************************************/
|
|
|
|
|
|
#include "lib/test/run.hpp"
|
|
#include "lib/verb-token.hpp"
|
|
#include "lib/util.hpp"
|
|
#include "lib/iter-adapter-stl.hpp"
|
|
#include "lib/format-string.hpp"
|
|
|
|
#include <boost/noncopyable.hpp>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <tuple>
|
|
|
|
using util::isnil;
|
|
using std::string;
|
|
using util::_Fmt;
|
|
using std::vector;
|
|
using std::move;
|
|
|
|
|
|
namespace lib {
|
|
namespace test{
|
|
namespace error = lumiera::error;
|
|
|
|
LUMIERA_ERROR_DEFINE(DIFF_CONFLICT, "Collision in diff application: contents of target not as expected.");
|
|
|
|
template<typename E>
|
|
struct DiffLanguage
|
|
{
|
|
class Receiver
|
|
{
|
|
public:
|
|
virtual ~Receiver() { } ///< this is an interface
|
|
|
|
virtual void ins(E e) =0;
|
|
virtual void del(E e) =0;
|
|
virtual void pick(E e) =0;
|
|
virtual void push(E e) =0;
|
|
};
|
|
|
|
using DiffVerb = VerbToken<Receiver, void(E)>;
|
|
using VerbTok = std::tuple<DiffVerb, E>;
|
|
|
|
struct DiffStep
|
|
: VerbTok
|
|
{
|
|
DiffVerb& verb() { return std::get<0>(*this); }
|
|
E elm() { return std::get<1>(*this); }
|
|
|
|
DiffStep(DiffVerb verb, E e)
|
|
: VerbTok(verb,e)
|
|
{ }
|
|
|
|
operator string() const
|
|
{
|
|
return string(verb()) + "("+string(elm())+")";
|
|
}
|
|
|
|
void
|
|
applyTo (Receiver& receiver)
|
|
{
|
|
verb().applyTo (receiver, elm());
|
|
}
|
|
};
|
|
|
|
#define DiffStep_CTOR(_ID_) \
|
|
static DiffStep _ID_(E e) { return {DiffVerb(&Receiver::_ID_, STRINGIFY(_ID_)), e }; }
|
|
|
|
DiffStep_CTOR(ins)
|
|
DiffStep_CTOR(del)
|
|
DiffStep_CTOR(pick)
|
|
DiffStep_CTOR(push)
|
|
|
|
};
|
|
|
|
template<class CON>
|
|
class DiffApplicationStrategy;
|
|
|
|
/**
|
|
* concrete strategy to apply a list diff to a target sequence given as vector.
|
|
* The implementation swaps aside the existing content of the target sequence
|
|
* and then consumes it step by step, while building up the altered content
|
|
* within the previously emptied target vector. Whenever possible, elements
|
|
* are moved directly to the target location.
|
|
* @throws lumiera::error::State when diff application fails due to the
|
|
* target sequence being different than assumed by the given diff.
|
|
* @warning behaves only EX_SANE in case of diff application errors,
|
|
* i.e. only partially modified / rebuilt sequence might be
|
|
* in the target when diff application is aborted
|
|
*/
|
|
template<typename E, typename...ARGS>
|
|
class DiffApplicationStrategy<vector<E,ARGS...>>
|
|
: public DiffLanguage<E>::Receiver
|
|
{
|
|
using Vec = vector<E,ARGS...>;
|
|
using Iter = typename Vec::iterator;
|
|
|
|
Vec orig_;
|
|
Vec& seq_;
|
|
Iter pos_;
|
|
|
|
bool
|
|
end_of_target()
|
|
{
|
|
return pos_ == orig_.end();
|
|
}
|
|
|
|
void
|
|
__expect_in_target (E const& e, Literal oper)
|
|
{
|
|
if (end_of_target())
|
|
throw error::State(_Fmt("Unable to %s element %s from target as demanded; "
|
|
"no (further) elements in target sequence") % oper % e
|
|
, LUMIERA_ERROR_DIFF_CONFLICT);
|
|
if (*pos_ != e)
|
|
throw error::State(_Fmt("Unable to %s element %s from target as demanded; "
|
|
"found element %s on current target position instead")
|
|
% oper % e % *pos_
|
|
, LUMIERA_ERROR_DIFF_CONFLICT);
|
|
}
|
|
|
|
void
|
|
__expect_further_elements()
|
|
{
|
|
if (end_of_target())
|
|
throw error::State("Premature end of target sequence; unable to apply diff further."
|
|
, LUMIERA_ERROR_DIFF_CONFLICT);
|
|
}
|
|
|
|
void
|
|
__expect_found (E const& e, Iter const& targetPos)
|
|
{
|
|
if (targetPos == orig_.end())
|
|
throw error::State(_Fmt("Premature end of sequence; unable to locate "
|
|
"element %s as reference point in target.") % e
|
|
, LUMIERA_ERROR_DIFF_CONFLICT);
|
|
}
|
|
|
|
|
|
/* == Implementation of the diff application primitives == */
|
|
|
|
void
|
|
ins(E e)
|
|
{
|
|
seq_.push_back(e);
|
|
}
|
|
|
|
void
|
|
del(E e)
|
|
{
|
|
__expect_in_target(e, "remove");
|
|
++pos_;
|
|
}
|
|
|
|
void
|
|
pick(E e)
|
|
{
|
|
__expect_in_target(e, "pick");
|
|
seq_.push_back (move(*pos_));
|
|
++pos_;
|
|
}
|
|
|
|
void
|
|
push(E anchor)
|
|
{
|
|
__expect_further_elements();
|
|
E e(move(*pos_)); // consume current source element
|
|
++pos_;
|
|
|
|
// locate the insert position behind the given reference anchor
|
|
Iter insertPos = std::find(pos_, orig_.end(), anchor);
|
|
__expect_found (anchor, insertPos);
|
|
|
|
// inserting the "pushed back" element behind the found position
|
|
// this might lead to reallocation and thus invalidate the iterators
|
|
auto currIdx = pos_ - orig_.begin();
|
|
orig_.insert (++insertPos, move(e));
|
|
pos_ = orig_.begin() + currIdx;
|
|
}
|
|
|
|
|
|
public:
|
|
explicit
|
|
DiffApplicationStrategy(vector<E>& targetVector)
|
|
: seq_(targetVector)
|
|
, pos_(seq_.begin())
|
|
{
|
|
swap (seq_, orig_); // pos_ still refers to original input sequence, which has been moved to orig_
|
|
seq_.reserve (targetVector.size() * 120 / 100); // heuristics for storage pre-allocation
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* generic builder to apply a list diff to a given target sequence.
|
|
* The usage pattern is as follows
|
|
* #. construct a DiffApplicator instance, wrapping the target sequence
|
|
* #. feed the list diff (sequence of diff verbs) to the #consume function
|
|
* #. the wrapped target sequence has been altered, to conform to the given diff
|
|
* @note a suitable DiffApplicationStrategy will be picked, based on the type
|
|
* of the concrete target sequence given at construction. (Effectively
|
|
* this means you need a suitable DiffApplicationStrategy specialisation,
|
|
* e.g. for a target sequence within a vector)
|
|
*/
|
|
template<class SEQ>
|
|
class DiffApplicator
|
|
: boost::noncopyable
|
|
{
|
|
using Val = typename SEQ::value_type;
|
|
using Diff = DiffLanguage<Val>;
|
|
|
|
using Receiver = DiffApplicationStrategy<SEQ>;
|
|
|
|
Receiver target_;
|
|
|
|
public:
|
|
explicit
|
|
DiffApplicator(SEQ& targetSeq)
|
|
: target_(targetSeq)
|
|
{ }
|
|
|
|
template<class DIFF>
|
|
void
|
|
consume (DIFF&& diff)
|
|
{
|
|
for ( ; diff; ++diff )
|
|
diff->applyTo(target_);
|
|
}
|
|
};
|
|
|
|
namespace {
|
|
template<typename SEQ>
|
|
struct _OnceT
|
|
{
|
|
typedef typename SEQ::value_type value_type;
|
|
typedef iter_stl::IterSnapshot<value_type> iterator;
|
|
};
|
|
}
|
|
|
|
template<class CON>
|
|
inline typename _OnceT<CON>::iterator
|
|
onceEach(CON const& con)
|
|
{
|
|
using OnceIter = typename _OnceT<CON>::iterator;
|
|
return OnceIter(con);
|
|
}
|
|
|
|
template<class VAL>
|
|
inline iter_stl::IterSnapshot<VAL>
|
|
onceEach(std::initializer_list<VAL> const& ili)
|
|
{
|
|
using OnceIter = iter_stl::IterSnapshot<VAL>;
|
|
return OnceIter(begin(ili), end(ili));
|
|
}
|
|
|
|
namespace {
|
|
|
|
using DataSeq = vector<string>;
|
|
|
|
#define TOK(id) id(STRINGIFY(id))
|
|
|
|
string TOK(a1), TOK(a2), TOK(a3), TOK(a4), TOK(a5);
|
|
string TOK(b1), TOK(b2), TOK(b3), TOK(b4);
|
|
|
|
struct TestDiff
|
|
: DiffLanguage<string>
|
|
{
|
|
using DiffSeq = typename _OnceT<std::initializer_list<DiffStep>>::iterator;
|
|
|
|
static DiffSeq
|
|
generate()
|
|
{
|
|
return onceEach({del(a1)
|
|
, del(a2)
|
|
, ins(b1)
|
|
, pick(a3)
|
|
, push(a5)
|
|
, pick(a5)
|
|
, ins(b2)
|
|
, ins(b3)
|
|
, pick(a4)
|
|
, ins(b4)
|
|
});
|
|
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************//**
|
|
* @test Demonstration/Concept: a description language for list differences.
|
|
* The representation is given as a linearised sequence of verb tokens.
|
|
* This test demonstrates the application of such a diff representation
|
|
* to a given source list, transforming this list to hold the intended
|
|
* target list contents.
|
|
*
|
|
* @see session-structure-mapping-test.cpp
|
|
*/
|
|
class DiffListApplication_test : public Test
|
|
{
|
|
|
|
virtual void
|
|
run (Arg)
|
|
{
|
|
DataSeq src({a1,a2,a3,a4,a5});
|
|
auto diff = TestDiff::generate();
|
|
CHECK (!isnil (diff));
|
|
|
|
DataSeq target = src;
|
|
DiffApplicator<DataSeq> application(target);
|
|
application.consume(diff);
|
|
|
|
CHECK (isnil (diff));
|
|
CHECK (!isnil (target));
|
|
CHECK (src != target);
|
|
CHECK (target == DataSeq({b1,a3,a5,b2,b3,a4,b4}));
|
|
}
|
|
};
|
|
|
|
|
|
/** Register this test class... */
|
|
LAUNCHER (DiffListApplication_test, "unit common");
|
|
|
|
|
|
|
|
}} // namespace lib::test
|