asset.hpp

Go to the documentation of this file.

/*
  ASSET.hpp  -  Superinterface: bookkeeping view of "things" present in the session
 
   Copyright (C)
     2008,            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_INTERFACE_ASSET_H
#define STEAM_INTERFACE_ASSET_H
 
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "include/logging.h"
#include "steam/asset/category.hpp"
#include "lib/hash-value.h"
#include "lib/p.hpp"
 
#include <type_traits>
#include <compare>
#include <string>
#include <vector>
#include <set>
 
 
using std::string;
using std::vector;
using std::set;
 
 
namespace steam {
namespace asset {
  
  namespace error = lumiera::error;
  
  using std::size_t;
  using std::shared_ptr;
  using std::static_pointer_cast;
  
  using lib::HashVal;
  
  
  
  template<class KIND>
  class ID
    {
      HashVal hash_;
    public:
      ID (HashVal id)        : hash_(id)         {}
      ID (const KIND& asset) : hash_(asset.getID()) {}
      operator HashVal() const { return hash_; }
      
      static ID INVALID;
    };
    
  class DB;
  class Asset;
  class AssetManager;
  typedef const ID<Asset>& IDA;
  typedef lib::P<Asset>       PAsset;
  typedef lib::P<const Asset> PcAsset;
 
  
  
  
  
  class Asset 
    : util::NonCopyable
    {
    public:
 
      struct Ident
        {
          string name;
          
          asset::Category category;
          
          const string org;
          
          const uint version;
 
          
          Ident (string const& n
                ,Category const& cat
                ,string const& o = "lumi"
                ,const uint ver=1);
          
          
          auto operator<=>(Ident const& oi)  const { return std::tie (   category,   org,   name)
                                                        <=> std::tie (oi.category,oi.org,oi.name); }
          bool operator== (Ident const& oi)  const { return 0 == *this <=> oi; }
          
          
          operator string ()  const;
          
          bool isValid()  const;
        };
      
      
      /* ===== Asset ID and Datafields ===== */
      
    public:
      const Ident ident;     
 
      virtual const ID<Asset>& getID()   const { return id; }
      
      
      bool operator== (Asset const& oa)  const { return ident  == oa.ident; }
      auto operator<=>(Asset const& 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);
      
      
    };
    
    
    
    
  template<class A>
  inline const PcAsset
  pAsset (shared_ptr<A> const& subPtr)
  {
    return static_pointer_cast<const Asset,A> (subPtr);
  }
  
  
  template <class X>
  struct is_pAsset : std::false_type { };
  
  template <class A>
  struct is_pAsset<shared_ptr<A>>
    : std::is_base_of<Asset, A>      { };
  
  
  template<class KIND>
  ID<KIND> ID<KIND>::INVALID = ID{0};
  
  
}} // namespace steam::asset
 
 
 
namespace proc_interface {
  
  using steam::asset::Asset;
  using steam::asset::Category;
  using steam::asset::ID;
  using steam::asset::IDA;
  using steam::asset::PAsset;
}
 
#endif