Ichthyostega
cfe54a5070
This extension is required to use GenNode as data source for text-template instantiation. I am aware that such a function could counter the design intent for GenNode, because it could be (ab)used to "just get the damn value" and then parse back the results...
810 lines
25 KiB
C++
810 lines
25 KiB
C++
/*
|
|
RECORD.hpp - collection to represent object-like data
|
|
|
|
Copyright (C) Lumiera.org
|
|
2015, 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.
|
|
|
|
*/
|
|
|
|
|
|
/** @file record.hpp
|
|
** Special collection to represent object-like data.
|
|
** To be used in a context where introspection, open, extensible definitions
|
|
** and loose coupling of data representation matters. Typically, structures
|
|
** defined in terms of Record elements are linked to the _actual core_
|
|
** representation of the same entities relying on [diff messages](\ref diff-language.hpp).
|
|
** Record is one of the supported flavours within the DataCap of GenNode elements,
|
|
** which in turn serve as the standard handle to refer to other elements, entities,
|
|
** attributes or references within the "backbone" of the Lumiera GUI.
|
|
**
|
|
** A Record holds
|
|
** - (optionally) a type-ID string
|
|
** - a collection of _named attributes_ (key-value data)
|
|
** - a list of _enclosed children_ (contents within the "scope" of this Record)
|
|
**
|
|
** # design decisions
|
|
** The Record type is shaped from its intended use: It serves to symbolically represent
|
|
** *objects* in the "external tree description". Here, "objects" means objects _for real_,
|
|
** i.e. with types, fields and an enclosed scope. Yet the term *external* means that we do not
|
|
** work on these objects right here, we only represent them, for later referral, _symbolically_.
|
|
**
|
|
** \par rationale
|
|
** The underlying theme and motivation of this design is negative: we do not want
|
|
** to build _yet another object system_. The object model of C++ is deemed adequate.
|
|
**
|
|
** This leads to the following decisions
|
|
** - the Record entity is itself an object and thus has an inner side, privately.
|
|
** The entrails of the Record can be reworked and tuned for performance
|
|
** - yet the Record has an external appearance, which makes it look flat and passive.
|
|
** This is to say, a Record has no visible functionality.
|
|
** - the parts or _realms_ within this symbolic representation are distinguished
|
|
** by convention solely
|
|
**
|
|
** * metadata is very limited and boils down to a type attribute known by name
|
|
** * children (scope contents) can be recognised by _not_ bearing a name
|
|
**
|
|
** Record entities are meant to be immutable. The proper way to alter a Record is
|
|
** to apply a [diff](\ref tree-diff.hpp). Yet for the _implementation_ of this
|
|
** diff handling, a Record::Mutator is provided, to allow controlled partial
|
|
** re-building of a given data element. Moreover, especially for Record<GenNode>,
|
|
** this mutator can be used for a DSL-style compact notation of a complete
|
|
** "object tree" -- a feature intended for writing unit tests.
|
|
**
|
|
** @remarks
|
|
** - the implementation is focused on the intended primary use case,
|
|
** which is to exchange diff messages drawn against a symbolic representation
|
|
** of a typed object tree. Especially, we assume that there is only a small
|
|
** number of attributes (so linear search for access by key is adequate).
|
|
** - moreover, we assume that the value type allows for somehow embedding
|
|
** the key of each attribute; the implementation needs an explicit
|
|
** specialisation of the binding functions for each value type.
|
|
** - this header defines a specialisation for VAL = std::string --
|
|
** while the most relevant specialisation for GenNode is provided
|
|
** alongside with this special, monadic value type.
|
|
** - an alternative implementation approach would have been to use a
|
|
** dedicated helper type to represent the collection of attributes.
|
|
** This type might then be specialised, e.g. to utilise an index table
|
|
** for key-value lookup. However, in the light of the intended usage
|
|
** of Record entities as tree nodes within a GenNode monad, such a
|
|
** more elaborate approach was deemed unnecessary for the time being.
|
|
**
|
|
** @see GenericRecord_test
|
|
**
|
|
*/
|
|
|
|
|
|
#ifndef LIB_DIFF_RECORD_H
|
|
#define LIB_DIFF_RECORD_H
|
|
|
|
|
|
#include "lib/error.hpp"
|
|
#include "lib/nocopy.hpp"
|
|
#include "lib/iter-adapter.hpp"
|
|
#include "lib/iter-adapter-stl.hpp"
|
|
#include "lib/itertools.hpp"
|
|
#include "lib/format-util.hpp" ///////////////////////////////TICKET #973 : investigate the impact of this inclusion on code size
|
|
#include "lib/util.hpp"
|
|
|
|
|
|
#include <algorithm>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
|
|
|
|
namespace lib {
|
|
|
|
template<class BA, class DEFAULT>
|
|
class PlantingHandle;
|
|
|
|
namespace idi {
|
|
class BareEntryID;
|
|
}
|
|
namespace diff{
|
|
|
|
namespace error = lumiera::error;
|
|
|
|
using util::isnil;
|
|
using std::string;
|
|
|
|
class TreeMutator;
|
|
|
|
template<typename VAL>
|
|
struct RecordSetup;
|
|
|
|
|
|
/**
|
|
* object-like record of data.
|
|
* For symbolic representation of "objects".
|
|
* A Record holds both \em attributes (key-value data)
|
|
* plus a list of \em enclosed children, which are conceived
|
|
* to be within the "scope" of this Record. Optionally, a \em typeID
|
|
* (metadata) may be defined. Otherwise, this typeID defaults to \c "NIL".
|
|
* The representation of attributes depends on the actual value type, which
|
|
* somehow need the ability to encode the keys within the value data.
|
|
* By default, a specialisation is given for string, using the \c "key = val"
|
|
* syntax. Yet the most relevant use case is \c Record<GenNode> -- using the
|
|
* embedded name-ID of the GenNode elements as key for attributes.
|
|
*
|
|
* Record elements are meant to be immutable; they can be created from a
|
|
* defining collection. However, we provide a #Mutator mechanism to allow
|
|
* for rebuilding and mutating symbolic data structures based on Records
|
|
* and GenNode. Essentially, Lumiera's diff framework relies on this.
|
|
*/
|
|
template<typename VAL>
|
|
class Record
|
|
{
|
|
using Storage = typename RecordSetup<VAL>::Storage;
|
|
using ElmIter = typename RecordSetup<VAL>::ElmIter;
|
|
using Access = typename RecordSetup<VAL>::Access;
|
|
|
|
|
|
string type_;
|
|
Storage attribs_;
|
|
Storage children_;
|
|
|
|
public:
|
|
static const string TYPE_NIL;
|
|
static const Symbol TYPE_NIL_SYM;
|
|
|
|
Record()
|
|
: type_(TYPE_NIL)
|
|
{ }
|
|
|
|
template<typename A, typename C>
|
|
Record(Symbol typeID, A&& att, C&& chi)
|
|
: type_(isnil(typeID)? TYPE_NIL:string(typeID))
|
|
, attribs_(std::forward<A> (att))
|
|
, children_(std::forward<C> (chi))
|
|
{ }
|
|
|
|
template<typename A, typename C>
|
|
Record(Symbol typeID, std::initializer_list<A> const&& att
|
|
, std::initializer_list<C> const&& chi)
|
|
: type_(isnil(typeID)? TYPE_NIL:string(typeID))
|
|
, attribs_(att)
|
|
, children_(chi)
|
|
{ }
|
|
|
|
template<typename SEQ>
|
|
explicit
|
|
Record (SEQ const& con)
|
|
: type_(TYPE_NIL)
|
|
{
|
|
auto p = std::begin(con);
|
|
auto e = std::end(con);
|
|
for ( ; p!=e && isAttribute(*p); ++p)
|
|
if (isTypeID (*p))
|
|
type_ = extractTypeID(*p);
|
|
else
|
|
attribs_.push_back (*p);
|
|
for ( ; p!=e; ++p)
|
|
children_.push_back (*p);
|
|
}
|
|
|
|
Record (std::initializer_list<VAL> const&& ili)
|
|
: Record(ili)
|
|
{ }
|
|
|
|
// all default copy operations acceptable
|
|
|
|
|
|
/** for diagnostic purpose */
|
|
operator std::string() const;
|
|
|
|
|
|
size_t
|
|
attribSize() const
|
|
{
|
|
return attribs_.size();
|
|
}
|
|
|
|
size_t
|
|
childSize() const
|
|
{
|
|
return children_.size();
|
|
}
|
|
|
|
bool
|
|
empty() const
|
|
{
|
|
return attribs_.empty()
|
|
and children_.empty();
|
|
}
|
|
|
|
|
|
string
|
|
getType() const
|
|
{
|
|
return type_;
|
|
}
|
|
|
|
bool
|
|
hasAttribute (string key) const
|
|
{
|
|
return attribs_.end() != findKey(key);
|
|
}
|
|
|
|
bool
|
|
contains (VAL const& val) const
|
|
{
|
|
return util::contains (children_, val);
|
|
}
|
|
|
|
Access
|
|
get (string key) const
|
|
{
|
|
ElmIter found = findKey (key);
|
|
if (attribs_.end() == found)
|
|
throw error::Invalid ("Record has no attribute \""+key+"\"");
|
|
else
|
|
return extractVal (*found);
|
|
}
|
|
|
|
Access
|
|
child (size_t idx) const
|
|
{
|
|
if (children_.size() <= idx)
|
|
throw error::Invalid ("Child index " +util::toString(idx)
|
|
+" out of bounds [0.."+util::toString(children_.size())
|
|
+"["
|
|
,error::LUMIERA_ERROR_INDEX_BOUNDS);
|
|
return children_[idx];
|
|
}
|
|
|
|
|
|
/**
|
|
* While otherwise immutable,
|
|
* a Record object can be remoulded
|
|
* with the help of a Mutator object
|
|
* @remarks a Mutator basically wraps a \em copy
|
|
* of the original object. After performing
|
|
* the desired changes, the altered copy can either
|
|
* be sliced out (by conversion), or moved overwriting
|
|
* an existing other Record instance (implemented as swap)
|
|
*/
|
|
class Mutator;
|
|
|
|
|
|
|
|
/**
|
|
* copy-initialise (or convert) from the given Mutator instance.
|
|
* @remarks need to code this explicitly, otherwise Record's
|
|
* build-from sequence templated ctor would kick in.
|
|
* @warning beware of initialiser lists. Record has a dedicated
|
|
* ctor to accept an initialiser list of GenNode elements,
|
|
* and GenNode's ctor is deliberately _not explicit,_ to ease
|
|
* building argument lists wrapped in GenNodes. When writing
|
|
* initialisation expressions inline, the compiler might pick
|
|
* the conversion path through initialiser list, which means
|
|
* the contents of the Mutator end up wrapped into a GenNode,
|
|
* which in turn becomes the only child of the new Record.
|
|
*/
|
|
Record (Mutator const& mut)
|
|
: Record((Record const&) mut)
|
|
{ }
|
|
Record (Mutator && mut)
|
|
: Record(std::move ((Record) mut))
|
|
{ }
|
|
|
|
friend class Mutator;
|
|
|
|
|
|
|
|
/* ==== Exposing scope and contents for iteration ====== */
|
|
|
|
using iterator = IterAdapter<ElmIter, const Record*>;
|
|
using scopeIter = typename iter_stl::_SeqT<const Storage>::Range;
|
|
using keyIter = TransformIter<scopeIter, string>;
|
|
using valIter = TransformIter<scopeIter, Access>;
|
|
|
|
/** default iteration exposes all data within this "object", starting with the attributes */
|
|
iterator begin () const { return iterator(this, attribs_.empty()? children_.begin() : attribs_.begin()); }
|
|
iterator end () const { return iterator(); }
|
|
|
|
scopeIter attribs() const { return iter_stl::eachElm(attribs_); }
|
|
scopeIter scope() const { return iter_stl::eachElm(children_); }
|
|
|
|
keyIter keys() const { return transformIterator(attribs(), extractKey); }
|
|
valIter vals() const { return transformIterator(attribs(), extractVal); }
|
|
|
|
protected: /* ==== API for the IterAdapter ==== */
|
|
|
|
/** Implementation of Iteration-logic: pull next element. */
|
|
friend void
|
|
iterNext (const Record*, ElmIter& pos)
|
|
{
|
|
++pos;
|
|
}
|
|
|
|
/** Implementation of Iteration-logic: detect iteration end.
|
|
* @remarks seamless continuation of the iteration when reaching
|
|
* the end of the attribute collection. In this implementation,
|
|
* we use the default constructed \c ITER() to mark iteration end.
|
|
*/
|
|
friend bool
|
|
checkPoint (const Record* src, ElmIter& pos)
|
|
{
|
|
REQUIRE (src);
|
|
static const ElmIter END;
|
|
if (pos != END && pos == src->attribs_.end() && !src->children_.empty())
|
|
{
|
|
pos = src->children_.begin();
|
|
return true;
|
|
}
|
|
else
|
|
if (pos != END && (pos != src->children_.end()))
|
|
return true;
|
|
else
|
|
{
|
|
pos = END;
|
|
return false;
|
|
} }
|
|
|
|
private:
|
|
/* === abstract attribute handling : needs specialisation === */
|
|
static bool isAttribute (VAL const& v);
|
|
static bool isTypeID (VAL const& v);
|
|
static string extractTypeID (VAL const& v);
|
|
static string renderAttribute (VAL const& a);
|
|
static string extractKey (VAL const& v);
|
|
static Access extractVal (VAL const& v);
|
|
template<typename X>
|
|
static VAL buildAttribute (string const& key, X&& payload);
|
|
|
|
|
|
ElmIter
|
|
findKey (string key) const
|
|
{
|
|
return std::find_if (attribs_.begin()
|
|
,attribs_.end()
|
|
,[=](VAL const& elm)
|
|
{
|
|
return key == extractKey(elm);
|
|
});
|
|
}
|
|
|
|
|
|
friend bool
|
|
operator== (Record const& r1, Record const& r2)
|
|
{
|
|
return r1.type_ == r2.type_
|
|
and r1.attribs_ == r2.attribs_
|
|
and r1.children_ == r2.children_;
|
|
}
|
|
|
|
friend bool
|
|
operator!= (Record const& r1, Record const& r2)
|
|
{
|
|
return not (r1 == r2);
|
|
}
|
|
};
|
|
|
|
template<typename VAL>
|
|
const Symbol Record<VAL>::TYPE_NIL_SYM = "NIL";
|
|
|
|
template<typename VAL>
|
|
const string Record<VAL>::TYPE_NIL = string(TYPE_NIL_SYM);
|
|
|
|
|
|
|
|
template<typename VAL>
|
|
class Record<VAL>::Mutator
|
|
: util::NonCopyable
|
|
{
|
|
using Rec = Record<VAL>;
|
|
|
|
Rec record_;
|
|
|
|
public:
|
|
Mutator()
|
|
: record_()
|
|
{ }
|
|
|
|
explicit
|
|
Mutator (Rec const& startingPoint)
|
|
: record_(startingPoint)
|
|
{ }
|
|
|
|
explicit
|
|
Mutator (Rec && startingPoint)
|
|
: record_(std::move (startingPoint))
|
|
{ }
|
|
|
|
operator Rec&()
|
|
{
|
|
return record_;
|
|
}
|
|
|
|
void
|
|
swap (Rec& existingInstance) noexcept
|
|
{
|
|
std::swap (existingInstance, record_);
|
|
}
|
|
|
|
bool
|
|
empty() const
|
|
{
|
|
return record_.empty();
|
|
}
|
|
|
|
|
|
/* === functions to alter contents === */
|
|
|
|
void
|
|
setType (string const& newTypeID)
|
|
{
|
|
record_.type_ = newTypeID;
|
|
}
|
|
|
|
Mutator&
|
|
type (string const& typeID)
|
|
{
|
|
setType (typeID);
|
|
return *this;
|
|
}
|
|
|
|
template<typename X>
|
|
Mutator&
|
|
set (string const& key, X&& content)
|
|
{
|
|
VAL attribute(Rec::buildAttribute (key, std::forward<X>(content)));
|
|
return set (std::move (attribute));
|
|
}
|
|
|
|
Mutator&
|
|
set (VAL&& attribute)
|
|
{
|
|
string key = Rec::extractKey(attribute);
|
|
if (isnil (key))
|
|
throw error::Invalid ("Attempt to set an attribute with empty key");
|
|
|
|
Rec::Storage& as =record_.attribs_;
|
|
auto found = std::find_if (as.begin(),as.end()
|
|
,[=](VAL const& elm)
|
|
{
|
|
return key == extractKey(elm);
|
|
});
|
|
if (as.end() == found)
|
|
as.push_back (std::forward<VAL> (attribute));
|
|
else
|
|
(*found) = (std::forward<VAL> (attribute));
|
|
return *this;
|
|
}
|
|
|
|
Mutator&
|
|
appendAttrib (VAL const& newAttrib)
|
|
{
|
|
REQUIRE (Rec::isAttribute(newAttrib));
|
|
record_.attribs_.push_back (newAttrib);
|
|
return *this;
|
|
}
|
|
|
|
Mutator&
|
|
appendChild (VAL const& newChild)
|
|
{
|
|
record_.children_.push_back (newChild);
|
|
return *this;
|
|
}
|
|
|
|
Mutator&
|
|
prependChild (VAL const& newChild)
|
|
{
|
|
record_.children_.insert (record_.children_.begin(), newChild);
|
|
return *this;
|
|
}
|
|
|
|
/* === low-level access (for diff application) === */
|
|
|
|
using BufferHandle = PlantingHandle<TreeMutator, TreeMutator>;
|
|
|
|
/** attachment point to receive and apply tree-diff changes.
|
|
* The actual implementation needs to be provided for concrete Record payload types;
|
|
* in case of Record<GenNode>, a default implementation for this feature is provided by the
|
|
* "diff framework", which offers a preconfigured binding to create a TreeMutator implementation,
|
|
* which can then be used for a DiffApplicator. This way, a Rec::Mutator can receive diff messages
|
|
* to reorder and reshape the contents.
|
|
* @param BufferHandle pointing to an (implementation provided) storage location, where this
|
|
* function is expected to construct a suitable TreeMutator, linked to the internals
|
|
* of this Record::Mutator.
|
|
* @see lib::diff::mutatorBinding()
|
|
* @see lib::diff::DiffApplicationStrategy
|
|
* @see tree-diff-application.hpp
|
|
* @see DiffTreeApplication_test usage example
|
|
*/
|
|
void buildMutator (BufferHandle);
|
|
|
|
auto
|
|
exposeToDiff()
|
|
{
|
|
return std::tie (record_.attribs_, record_.children_);
|
|
}
|
|
|
|
|
|
/** get the tail element.
|
|
* @return either the last child, or the last attribute, when children are empty.
|
|
* @note typically this might be used to get back at the element "just added",
|
|
* as when muting a child node in diff application. But there is a loophole:
|
|
* we might have added an attribute even when there are already children.
|
|
*/
|
|
VAL const&
|
|
accessLast()
|
|
{
|
|
if (record_.empty())
|
|
throw error::State("Record is empty, unable to access (last) element.");
|
|
|
|
if (record_.children_.empty())
|
|
return record_.attribs_.back();
|
|
else
|
|
return record_.children_.back();
|
|
}
|
|
|
|
|
|
/* === extension point for building specific value types === */
|
|
/*
|
|
* the following builder functions need to be specialised
|
|
* to create a Record holding specific value types,
|
|
* especially for building a tree like structure
|
|
* with GenNode holding a Record<GenNode>
|
|
*/
|
|
|
|
VAL genNode();
|
|
VAL genNode(idi::BareEntryID rawID);
|
|
VAL genNode(string const& symbolicID);
|
|
|
|
template<typename X, typename...ARGS>
|
|
Mutator& attrib (string const& key, X&& initialiser, ARGS&& ...args)
|
|
{
|
|
set (key, std::forward<X>(initialiser));
|
|
return attrib (std::forward<ARGS>(args)...);
|
|
}
|
|
Mutator& attrib () { return *this; } // argument recursion end
|
|
|
|
|
|
template<typename X, typename...ARGS>
|
|
Mutator& scope (X const& initialiser, ARGS&& ...args)
|
|
{
|
|
appendChild (VAL(initialiser));
|
|
return scope (std::forward<ARGS>(args)...);
|
|
}
|
|
Mutator& scope () { return *this; }
|
|
|
|
};
|
|
|
|
|
|
/** open an existing record for modification in-place.
|
|
* @warning this function undermines the immutability of Record
|
|
* @remarks exploits the specific and known memory layout of Rec::Mutator.
|
|
* This trickery is necessary to avoid copying a large and possibly
|
|
* nested object tree; this happens when applying a diff, when
|
|
* recursively descending into nested child objects.
|
|
* @todo do we have a design mismatch here?? /////////////////////////////////////////TICKET #970
|
|
* @see tree-diff-application.hpp
|
|
*/
|
|
template<typename VAL>
|
|
inline typename Record<VAL>::Mutator&
|
|
mutateInPlace (Record<VAL>& record_to_mutate)
|
|
{
|
|
return reinterpret_cast<typename Record<VAL>::Mutator &> (record_to_mutate);
|
|
}
|
|
|
|
|
|
/**
|
|
* wrapped record reference.
|
|
* A helper for lib::GenNode and the diff representation.
|
|
* RecordRef is copyable and movable, but like a reference
|
|
* can not be rebound. It can be used to refer to a subtree
|
|
* within the diff representation, without the need to copy.
|
|
* @remarks this is almost identical to std::ref, with the
|
|
* notable difference that it can be default-created
|
|
* into "bottom" state; this also implies to have
|
|
* a NULL check on dereferentiation.
|
|
*/
|
|
template<typename VAL>
|
|
class RecordRef
|
|
{
|
|
using Target = Record<VAL>;
|
|
|
|
Target* record_;
|
|
|
|
public:
|
|
/** by default create an
|
|
* invalid ("bottom") reference */
|
|
RecordRef() noexcept
|
|
: record_(nullptr)
|
|
{ }
|
|
|
|
/** create a reference bound to
|
|
* the given target; can not be rebound */
|
|
RecordRef(Target& o) noexcept
|
|
: record_(&o)
|
|
{ }
|
|
|
|
/** prevent moving into black hole */
|
|
RecordRef(Target&&) = delete;
|
|
|
|
RecordRef(RecordRef const&) = default;
|
|
RecordRef(RecordRef &&) = default;
|
|
|
|
/** references can not be reassigned */
|
|
RecordRef& operator= (RecordRef const&) = delete;
|
|
RecordRef& operator= (RecordRef &) = delete;
|
|
|
|
/** assignment is not allowed, but moving is */
|
|
RecordRef&
|
|
operator= (RecordRef &&o)
|
|
{
|
|
std::swap(record_, o.record_);
|
|
return *this;
|
|
}
|
|
|
|
|
|
explicit
|
|
operator bool() const
|
|
{
|
|
return bool(record_);
|
|
}
|
|
|
|
bool
|
|
empty() const
|
|
{
|
|
return not record_;
|
|
}
|
|
|
|
/** target is accessed by cast
|
|
* @throws error::Logic on bottom reference
|
|
*/
|
|
operator Target&() const
|
|
{
|
|
if (!record_)
|
|
throw error::Logic("attempt to dereference an unbound record reference"
|
|
,error::LUMIERA_ERROR_BOTTOM_VALUE);
|
|
return *record_;
|
|
}
|
|
|
|
Target*
|
|
get() const noexcept
|
|
{
|
|
return record_;
|
|
}
|
|
|
|
operator string() const
|
|
{
|
|
return "Ref->" + (empty()? util::BOTTOM_INDICATOR
|
|
: string(*record_));
|
|
}
|
|
|
|
/** @note equality of references (instance pointers), not targets */
|
|
friend bool
|
|
operator== (RecordRef const& r1, RecordRef const& r2)
|
|
{
|
|
return r1.record_ == r2.record_;
|
|
}
|
|
friend bool
|
|
operator!= (RecordRef const& r1, RecordRef const& r2)
|
|
{
|
|
return r1.record_ != r2.record_;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
/* === Extension point: Specialisations for attribute handling === */
|
|
|
|
/**
|
|
* Type configuration (extension point).
|
|
* Data storage and access types.
|
|
*/
|
|
template<>
|
|
struct RecordSetup<string>
|
|
{
|
|
using Storage = std::vector<string>;
|
|
using ElmIter = typename Storage::const_iterator;
|
|
using Access = string; ///< data access by value copy
|
|
};
|
|
|
|
|
|
|
|
|
|
/* default handling defined for Record<string> */
|
|
|
|
template<>
|
|
inline string
|
|
Record<string>::extractKey (string const& v)
|
|
{
|
|
size_t pos = v.find('=');
|
|
if (string::npos == pos)
|
|
return "";
|
|
else
|
|
return util::trim (v.substr (0,pos));
|
|
}
|
|
|
|
template<>
|
|
inline string
|
|
Record<string>::extractVal (string const& v)
|
|
{
|
|
size_t pos = v.find('=');
|
|
if (string::npos == pos)
|
|
return v;
|
|
else
|
|
return util::trim (v.substr (pos+1, v.length() - pos));
|
|
}
|
|
|
|
template<>
|
|
inline bool
|
|
Record<string>::isAttribute (string const& v)
|
|
{
|
|
return string::npos != v.find('=');
|
|
}
|
|
|
|
template<>
|
|
inline bool
|
|
Record<string>::isTypeID (string const& v)
|
|
{
|
|
return isAttribute(v)
|
|
&& "type" == extractKey(v);
|
|
}
|
|
|
|
template<>
|
|
inline string
|
|
Record<string>::extractTypeID (string const& v)
|
|
{
|
|
return extractVal(v);
|
|
}
|
|
|
|
template<>
|
|
inline string
|
|
Record<string>::renderAttribute (string const& attrib)
|
|
{
|
|
return extractKey(attrib) + " = " + extractVal(attrib);
|
|
}
|
|
|
|
template<>
|
|
template<typename X>
|
|
inline string
|
|
Record<string>::buildAttribute (string const& key, X&& payload)
|
|
{
|
|
return string(key + " = " + extractVal(payload));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* === Diagnostics === */
|
|
|
|
template<typename VAL>
|
|
Record<VAL>::operator std::string() const
|
|
{
|
|
using util::join;
|
|
using lib::transformIterator;
|
|
|
|
return "Rec("
|
|
+ (TYPE_NIL==type_? "" : type_)
|
|
+ (isnil(this->attribs())? "" : "| "+join (transformIterator (this->attribs(), renderAttribute))+" ")
|
|
+ (isnil(this->scope())? "" : "|{"+join (this->scope())+"}")
|
|
+ ")"
|
|
;
|
|
}
|
|
|
|
|
|
|
|
}} // namespace lib::diff
|
|
#endif /*LIB_DIFF_GEN_NODE_H*/
|