placement-index.hpp

Go to the documentation of this file.

/*
  PLACEMENT-INDEX.hpp  -  tracking individual Placements and their relations
 
   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
*/
 
 
#ifndef STEAM_MOBJECT_PLACEMENT_INDEX_H
#define STEAM_MOBJECT_PLACEMENT_INDEX_H
 
#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/itertools.hpp"
#include "steam/mobject/placement.hpp"
#include "steam/mobject/placement-ref.hpp"
#include "lib/nocopy.hpp"
#include "lib/util.hpp"
 
#include <unordered_map>
#include <memory>
#include <vector>
 
namespace std {
  
  template<>
  struct hash<steam::mobject::PlacementMO::ID>
  {
    size_t
    operator() (steam::mobject::PlacementMO::ID const& val)  const noexcept
      {
        return hash_value(val);
      }
  };
}
 
 
namespace lumiera {
namespace error {
  LUMIERA_ERROR_DECLARE (NOT_IN_SESSION);   
  LUMIERA_ERROR_DECLARE (PLACEMENT_TYPE);   
  LUMIERA_ERROR_DECLARE (NONEMPTY_SCOPE);   
}}
 
namespace steam {
namespace mobject {
  
  class MObject;
  
namespace session {
  
  using std::unique_ptr;
  
  
  template<typename PLA>
  struct BuildID;
  
  template<typename MO, typename BMO>
  struct BuildID<Placement<MO,BMO>>
    {
      using Type   = PlacementMO::Id<MO>;
      using Target = MO                 ;
    };
  
  
  
  class PlacementIndex
    : util::NonCopyable
    {
      class Table;
      class Validator;
      
      unique_ptr<Table> pTab_;
      
      
      using              _PID = PlacementMO::ID;
      using         ScopeIter = std::unordered_multimap<_PID,_PID>::const_iterator;
      using    ScopeRangeIter = lib::RangeIter<ScopeIter>;
      using _ID_TableIterator = lib::TransformIter<ScopeRangeIter, PlacementMO&>;
      
      
      
    public:
      using PRef = PlacementRef<MObject>;
      using ID = PlacementMO::ID const&;
      
      using iterator = _ID_TableIterator;
      
      
      /* == query operations == */
      
      PlacementMO& find (ID)                         const;
      
      template<class MO>
      Placement<MO>&  find (PlacementMO::Id<MO>)     const;
      template<class MO>
      Placement<MO>&  find (PlacementRef<MO> const&) const;
      
      PlacementMO& getScope (PlacementMO const&)     const;
      PlacementMO& getScope (ID)                     const;
      
      iterator getReferrers (ID)                     const;
      
      
      PlacementMO& getRoot()                         const;
      
      size_t size()                                  const;
      bool contains (PlacementMO const&)             const;
      bool contains (ID)                             const;
      
      bool isValid()                                 const;
      
      
      
      
      /* == mutating operations == */
      
      ID   insert (PlacementMO const& newObj, ID targetScope);
      bool remove (PlacementMO&);
      bool remove (ID);
      
      template<class PLA>
      BuildID<PLA>::Type insert (PLA const&, ID);
      
      
      
      PlacementIndex(PlacementMO const&);
     ~PlacementIndex() ;
      
      void clear (ID targetScope);
      void clear ();
      
    };
  
  
  
  
  
  
  
  
  /* === forwarding implementations of the templated API === */
  
  
  namespace { // shortcuts...
    
    template<class MOX>
    inline void
    ___check_compatibleType(PlacementMO& questionable)
    {
      if (!questionable.isCompatible<MOX>())
        throw lumiera::error::Logic ("Attempt to retrieve a Placement of specific type, "
                                     "while the actual type of the pointee (MObject) "
                                     "registered within the index isn't compatible with the "
                                     "requested specific MObject subclass"
                                    , LERR_(PLACEMENT_TYPE));
    }
    
    inline void
    __check_knownID(PlacementIndex const& idx, PlacementMO::ID id)
    {
    if (!id)
      throw lumiera::error::Logic ("Encountered a NIL Placement-ID marker"
                                  , LERR_(BOTTOM_PLACEMENTREF));
    if (!idx.contains (id))
      throw lumiera::error::Invalid ("Accessing Placement not registered within the index"
                                    , LERR_(NOT_IN_SESSION));              
    }
  }//(End) shortcuts
  
  
  
  
  template<class MO>
  inline Placement<MO>&
  PlacementIndex::find (PlacementMO::Id<MO> id)  const
  {
    PlacementMO& result (find ((ID)id));
    
    ___check_compatibleType<MO> (result);
    return static_cast<Placement<MO>&> (result);
  }
  
  
  template<class MO>
  inline Placement<MO>&
  PlacementIndex::find (PlacementRef<MO> const& pRef)  const
  {
    PlacementMO::Id<MO> id (pRef);
    return find (id);
  }
  
  
  inline Placement<MObject>&
  PlacementIndex::getScope (PlacementMO const& p)  const
  {
    return getScope(p.getID());
  }
  
  
  inline bool
  PlacementIndex::contains (PlacementMO const& p)  const
  {
    return contains (p.getID());
  }
  
  
  template<class PLA>
  BuildID<PLA>::Type
  PlacementIndex::insert (PLA const& newObj, ID targetScope)
  {
    using TargetMO = BuildID<PLA>::Target;
    PlacementMO const& genericPlacement(newObj);
    
    return find (insert (genericPlacement, targetScope))
           .template recastID<TargetMO>();
  }
  
  
  inline bool
  PlacementIndex::remove (PlacementMO& p)
  {
    return remove (p.getID());
  }
  
  
  
}}} // namespace steam::mobject::session
#endif