/scr/tee1/isis/lib/Core/CoreUtils/propmap.hpp

Go to the documentation of this file.

//
// C++ Interface: propmap
//
// Description:
//
//
// Author: Enrico Reimer<reimer@cbs.mpg.de>, (C) 2009
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef ISISPROPMAP_HPP
#define ISISPROPMAP_HPP

#include <map>
#include <string>

#include "common.hpp"
#include "property.hpp"
#include "log.hpp"
#include "istring.hpp"
#include <set>
#include <algorithm>

namespace isis
{
namespace util
{
namespace _internal
{
class treeNode; //predeclare treeNode -- we'll need it in PropertyMap
}

class PropertyMap : protected std::map<util::istring, _internal::treeNode>
{
public:
    typedef key_type KeyType;
    typedef std::set<KeyType, key_compare> KeyList;
    typedef std::map<KeyType, std::pair<PropertyValue, PropertyValue>, key_compare> DiffMap;
    typedef std::map<KeyType, PropertyValue> FlatMap;

    struct PropPath: public std::list<KeyType> {
        PropPath() {}
        PropPath( const char *key ): std::list<KeyType>( util::stringToList<KeyType>( util::istring( key ), pathSeperator ) ) {}
        PropPath( const KeyType &key ): std::list<KeyType>( util::stringToList<KeyType>( key, pathSeperator ) ) {}
        PropPath( const std::list<KeyType> &path ): std::list<KeyType>( path ) {}
    };
private:
    typedef std::map<KeyType, mapped_type, key_compare> Container;
    typedef PropPath::const_iterator propPathIterator;

    static const char pathSeperator = '/';

    // internal predicats
    struct trueP {  bool operator()( const_reference ref )const;};
    struct invalidP {   bool operator()( const_reference ref )const;};
    struct treeInvalidP {   bool operator()( const_reference ref )const;};
    struct listP {  bool operator()( const_reference ref )const;};

    // internal functors
    template<class Predicate> struct walkTree;

    // internal tool-backends
    void joinTree( const PropertyMap &other, bool overwrite, KeyType prefix, KeyList &rejects );
    void diffTree( const PropertyMap &other, PropertyMap::DiffMap &ret, KeyType prefix ) const;

    static mapped_type &fetchEntry( PropertyMap &root, const propPathIterator at, const propPathIterator pathEnd );
    mapped_type &fetchEntry( const PropPath &path );

    static const mapped_type *findEntry( const util::PropertyMap &root, const propPathIterator at, const propPathIterator pathEnd );
    const mapped_type *findEntry( const PropPath &path )const;

    bool recursiveRemove( PropertyMap &root, const propPathIterator at, const propPathIterator pathEnd );

protected:
    template<typename T> class NeededsList: public std::list<PropPath>
    {
    public:
        NeededsList() {
            const std::list< PropertyMap::KeyType > buff = util::stringToList<PropertyMap::KeyType>( T::neededProperties ); //@todo really bad voodoo
            assign( buff.begin(), buff.end() );
        }
        void applyTo( PropertyMap &props ) {
            BOOST_FOREACH( const PropPath & ref, *this ) {
                props.addNeeded( ref );
            }
        }
    };
    // rw-backends

    template<class Predicate> const KeyList genKeyList()const {
        KeyList k;
        std::for_each( begin(), end(), walkTree<Predicate>( k ) );
        return k;
    }
    void addNeeded( const PropPath &path );

    void removeEqual( const PropertyMap &other, bool removeNeeded = false );

    void toCommonUnique( PropertyMap &common, std::set<KeyType> &uniques, bool init )const;

    void makeFlatMap( FlatMap &out, KeyType key_prefix = "" )const;

    const std::vector<PropertyValue> &propertyValueVec( const PropPath &path )const;

    std::vector<PropertyValue> &propertyValueVec( const PropPath &path );
public:
    // constructors
    PropertyMap( const Container &src );
    PropertyMap();

    bool operator==( const PropertyMap &src )const;

    // Common rw-accessors

    const PropertyValue &propertyValue( const PropPath &path )const;

    PropertyValue &propertyValue( const PropPath &path );

    PropertyMap &branch( const PropPath &path );

    const PropertyMap &branch( const PropPath &path )const;

    bool remove( const PropPath &path );

    bool remove( const PropertyMap &removeMap, bool keep_needed = false );

    bool remove( const KeyList &removeList, bool keep_needed = false );

    bool hasProperty( const PropPath &path )const;

    KeyType find( KeyType key, bool allowProperty = true, bool allowBranch = false )const;

    KeyList findLists()const;

    bool hasBranch( const PropPath &path )const;

    // tools

    bool isValid()const;

    bool isEmpty()const;

    const KeyList getKeys()const;

    const KeyList getMissing()const;

    DiffMap getDifference( const PropertyMap &second )const;

    PropertyMap::KeyList join( const PropertyMap &other, bool overwrite = false );

    bool transform( const PropPath &from, const PropPath &to, int dstID, bool delSource = true );

    template<typename DST> bool transform( const PropPath &from, const PropPath &to, bool delSource = true ) {
        checkType<DST>();
        return transform( from, to, Value<DST>::staticID, delSource );
    }

    // Additional get/set - Functions
    //@todo make sure the type specific behaviour is as documented
    template<typename T> PropertyValue &setPropertyAs( const PropPath &path, const T &val ) {
        PropertyValue &ret = propertyValue( path );

        if( ret.isEmpty() ) {
            const bool needed = ret.isNeeded();
            ( ret = val ).needed() = needed;
        } else if( ret.is<T>() ) {
            ret.castTo<T>() = val;
        } else { // don't overwrite already set properties with a different type
            LOG( Runtime, error ) << "Property " << MSubject( path ) << " is already set to " << MSubject( ret.toString( true ) ) << " won't override with " << MSubject( Value<T>( val ).toString( true ) );
        }

        return ret;
    }

    template<typename T> T getPropertyAs( const PropPath &path )const;

    bool rename( const PropPath &from, const PropPath &to );

    FlatMap getFlatMap( )const;

    std::ostream &print( std::ostream &out, bool label = false )const;
};
}
}

namespace std //predeclare streaming output -- we'll need it in treeNode
{
template<typename charT, typename traits>
basic_ostream<charT, traits>& operator<<( basic_ostream<charT, traits> &out, const isis::util::_internal::treeNode &s );
template<typename charT, typename traits>
basic_ostream<charT, traits>& operator<<( basic_ostream<charT, traits> &out, const isis::util::PropertyMap &s );
}


// OK, lets define treeNode
namespace isis
{
namespace util
{
API_EXCLUDE_BEGIN
namespace _internal
{
class treeNode
{
    PropertyMap m_branch;
    std::vector<PropertyValue> m_leaf;
public:
    treeNode(): m_leaf( 1 ) {}
    bool empty()const {
        return m_branch.isEmpty() && m_leaf[0].isEmpty();
    }
    bool is_leaf()const {
        LOG_IF( ! ( m_branch.isEmpty() || m_leaf[0].isEmpty() ), Debug, error ) << "There is a non empty leaf at a branch. This should not be.";
        return m_branch.isEmpty();
    }
    const PropertyMap &getBranch()const {
        return m_branch;
    }
    PropertyMap &getBranch() {
        return m_branch;
    }
    std::vector<PropertyValue> &getLeaf() {
        assert( is_leaf() );
        return m_leaf;
    }
    const std::vector<PropertyValue> &getLeaf()const {
        assert( is_leaf() );
        return m_leaf;
    }
    bool operator==( const treeNode &ref )const {
        return m_branch == ref.m_branch && m_leaf == ref.m_leaf;
    }
    void insert( const treeNode &ref ) {
        m_branch = ref.m_branch;
        m_leaf.resize( ref.m_leaf.size() );
        std::vector<PropertyValue>::iterator dst = m_leaf.begin();
        BOOST_FOREACH( std::vector<PropertyValue>::const_reference src, ref.m_leaf ) {
            const bool needed = dst->isNeeded();
            ( *dst = src ).needed() = needed;;
        }
    }
    std::string toString()const {
        std::ostringstream o;
        o << *this;
        return o.str();
    }
};
}
API_EXCLUDE_END

// and now we can define walkTree (needs treeNode to be defined)

template<class Predicate> struct PropertyMap::walkTree {
    KeyList &m_out;
    const KeyType m_prefix;
    walkTree( KeyList &out, const KeyType &prefix ): m_out( out ), m_prefix( prefix ) {}
    walkTree( KeyList &out ): m_out( out ) {}
    void operator()( const_reference ref ) const {
        const KeyType name = ( m_prefix != "" ? m_prefix + "/" : "" ) + ref.first;

        if ( ref.second.is_leaf() ) {
            if ( Predicate()( ref ) )
                m_out.insert( m_out.end(), name );
        } else {
            const PropertyMap &sub = ref.second.getBranch();
            std::for_each( sub.begin(), sub.end(), walkTree<Predicate>( m_out, name ) );
        }
    }
};

// as well as PropertyMap::getProperty ...
template<typename T> T PropertyMap::getPropertyAs( const PropPath &path ) const
{
    const mapped_type *entry = findEntry( path );

    if( entry ) {
        const PropertyValue &ref = entry->getLeaf()[0];

        if( !ref.isEmpty() )
            return ref.as<T>();
    }

    LOG( Debug, warning ) << "Returning " << Value<T>().toString( true ) << " because property " << path << " does not exist";
    return T();
}

}
}

// and finally define the streaming output for treeNode
namespace std
{
template<typename charT, typename traits>
basic_ostream<charT, traits>& operator<<( basic_ostream<charT, traits> &out, const isis::util::PropertyMap::PropPath &s )
{
    isis::util::listToOStream( s.begin(), s.end(), out, "/", "", "" );
    return out;
}
template<typename charT, typename traits>
basic_ostream<charT, traits>& operator<<( basic_ostream<charT, traits> &out, const isis::util::_internal::treeNode &s )
{
    if( s.is_leaf() ) {
        vector< isis::util::PropertyValue > vec = s.getLeaf();
        isis::util::listToOStream( vec.begin(), vec.end(), out );
    } else
        out << "[[Subtree with " << s.getBranch().getKeys().size() << " elements]]";

    return out;
}
template<typename charT, typename traits>
basic_ostream<charT, traits>& operator<<( basic_ostream<charT, traits> &out, const isis::util::PropertyMap &s )
{
    isis::util::PropertyMap::FlatMap buff = s.getFlatMap();
    isis::util::listToOStream( buff.begin(), buff.end(), out );
    return out;
}
}

#endif