proc/asset.hpp

Go to the documentation of this file.

/*
  ASSET.hpp  -  Superinterface: bookeeping view of "things" present in the session
 
  Copyright (C)         Lumiera.org
    2008,               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.
 
*/

#ifndef PROC_INTERFACE_ASSET_H
#define PROC_INTERFACE_ASSET_H


#include "proc/asset/category.hpp"
#include "common/error.hpp"
#include "common/p.hpp"

#include <boost/type_traits/is_base_of.hpp>
#include <boost/operators.hpp>
#include <boost/noncopyable.hpp>

#include <cstddef>
#include <string>
#include <vector>
#include <set>


using std::string;
using std::vector;
using std::set;



namespace asset
  {
  
  using std::size_t;
  using std::tr1::shared_ptr;
  using std::tr1::static_pointer_cast;

  using lumiera::P;
  
  
  template<class KIND>
  class ID
    {
    public:
      const size_t hash;
      ID (size_t id)         : hash(id)         {}
      ID (const KIND& asset) : hash(asset.getID()) {}
      operator size_t()  const { return hash; }
    };
    
  class DB;
  class Asset;
  class AssetManager;
  typedef const ID<Asset>& IDA;
  typedef P<Asset>       PAsset;
  typedef P<const Asset> PcAsset;

  
  
  
  
  class Asset 
    : boost::totally_ordered1< Asset,
        boost::noncopyable>
    {
    public:

      struct Ident
        : boost::totally_ordered<Ident>
        {
          string name;
    
          asset::Category category;
    
          const string org;
    
          const uint version;

          
          Ident (const string& n, 
                 const Category& cat, 
                 const string& o = "lumi", 
                 const uint ver=1);
          
          
          int compare (const Ident& other)   const;

          bool operator== (const Ident& oi)  const { return compare (oi) ==0; }
          bool operator<  (const Ident& oi)  const { return compare (oi) < 0; }
    
          operator string ()  const;
        };
      
         
      /* ===== Asset ID and Datafields ===== */
        
    public:    
      const Ident ident;     

      virtual const ID<Asset>& getID()   const { return id; }
      
      
      bool operator== (const Asset& oa)  const { return ident == oa.ident; }
      bool operator<  (const Asset& oa)  const { return ident <  oa.ident; }
          
      virtual operator string ()  const;
      
      
      
    protected:
      const ID<Asset> id;   

      set<string> groups;

      const string shortDesc;

      const string longDesc;
      
      vector<PAsset> parents;
      vector<PAsset> dependants;
      
      bool enabled;

      
      
    protected:
      Asset (const Ident& idi);
      virtual ~Asset()           = 0;    
      
      virtual void unlink ();
      
      virtual void unlink (IDA target);
      
      void defineDependency (PAsset parent);
      void defineDependency (Asset& parent); 
      
      friend class AssetManager;
      friend class DB;
      
    private:
      void unregister (PAsset& other);



    
    public:
      const vector<PAsset>& getParents ()  const { return parents; }
      
      const vector<PAsset>& getDependant ()  const { return dependants; }
      
      bool isActive ()  const;
      
      bool enable (bool on=true)  throw(lumiera::error::State);
      
      
    };
    
    
    
    
    /* ====== ordering of Assets and Asset-Pointers ====== */
    
    inline int 
    Asset::Ident::compare (const Asset::Ident& oi)  const
    { 
      int res;
      if (0 != (res=category.compare (oi.category)))  return res;
      if (0 != (res=org.compare (oi.org)))            return res;
      return name.compare (oi.name);
    }
    
    
    template<class A>
    inline const PcAsset
    pAsset (const shared_ptr<A>& subPtr)
    {
      return static_pointer_cast<const Asset,A> (subPtr);
    }
    
    
    template <class X>
    struct is_pAsset : boost::false_type {};
    
    template <class A>
    struct is_pAsset<shared_ptr<A> >
      : boost::is_base_of<Asset, A>      {}; 
    
    
    inline string str (const PcAsset& a) 
    {
      if (a)
        return string (*a.get());
      else
        return "Asset(NULL)";
    }
    
    

} // namespace asset



namespace proc_interface
  {
  using asset::Asset;
  using asset::Category;
  using asset::ID;
  using asset::IDA;
  using asset::PAsset;
}

#endif

---