/export/development/ViennaData/release/ViennaData-1.0.1/viennadata/api.hpp

Go to the documentation of this file.

/* =======================================================================
   Copyright (c) 2010, Institute for Microelectronics, TU Vienna.
   http://www.iue.tuwien.ac.at
                             -----------------
                     ViennaData - The Vienna Data Storage Library
                             -----------------

   authors:    Karl Rupp                          rupp@iue.tuwien.ac.at

   license:    MIT (X11), see file LICENSE in the ViennaData base directory
======================================================================= */

#ifndef VIENNADATA_INTERFACE_HPP
#define VIENNADATA_INTERFACE_HPP

#include "forwards.h"
#include "viennadata/data_container.hpp"
#include "viennadata/key_value_registration.hpp"
#include "viennadata/config/default_data_for_key.hpp"

namespace viennadata
{


  template <typename KeyType,
            typename DataType>
  class data_accessor_with_key
  {
    public:
      data_accessor_with_key(KeyType const & key) : key_(key) {}
      
      template <typename ObjectType>
      DataType & operator()(ObjectType const & el)
      {
        //std::cout << "Get data from element" << std::endl;
        return data_container<KeyType, DataType, ObjectType>::instance().access(el, key_);
      }
      
    private:
      KeyType const & key_;    
  };

  template <typename KeyType,
            typename DataType>
  class data_accessor_no_key
  {
    public:
      data_accessor_no_key() {}
      
      template <typename ObjectType>
      typename data_container<KeyType, DataType, ObjectType>::reference //note: a plain 'DataType &' is not compatible with std::vector<bool>, which returns a bit_reference!
      operator()(ObjectType const & el)
      {
    
        //std::cout << "Get data from element" << std::endl;
        return data_container<KeyType, DataType, ObjectType>::instance().access(el);
      }
  };
  
  
  // data getter and setter:
  template <typename KeyType,
            typename DataType>
  data_accessor_with_key<KeyType, DataType> access(KeyType const & key)
  {
    return data_accessor_with_key<KeyType, DataType>(key);
  }

  template <typename KeyType>
  data_accessor_with_key<KeyType, typename config::default_data_for_key<KeyType>::type> access(KeyType const & key)
  {
    return data_accessor_with_key<KeyType, typename config::default_data_for_key<KeyType>::type>(key);
  }



  template <typename KeyType,
            typename DataType>
  data_accessor_no_key<KeyType, DataType> access()
  {
    return data_accessor_no_key<KeyType, DataType>();
  }
  
  template <typename KeyType>
  data_accessor_no_key<KeyType, typename config::default_data_for_key<KeyType>::type > access()
  {
    return data_accessor_no_key<KeyType, typename config::default_data_for_key<KeyType>::type >();
  }
  

  template <typename KeyType,
            typename DataType>
  class data_erasor_with_key
  {
    public:
      data_erasor_with_key(KeyType const & k) : key(k) {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el)
      {
        data_container<KeyType, DataType, ObjectType>::instance().erase(el, key);
      }
    private:
      KeyType const & key;
  };
  
  //prevent messing around with all-type and supplied key:
  template <typename KeyType>
  class data_erasor_with_key<KeyType, all>
  {
    typedef typename error_indicator<KeyType>::ERROR_NO_KEY_ARGUMENT_ALLOWED_WHEN_USING_ERASE_FUNCTION_WITH_ALL   error_type;
  };

  template <typename DataType>
  class data_erasor_with_key<all, DataType>
  {
    typedef typename error_indicator<DataType>::ERROR_NO_KEY_ARGUMENT_ALLOWED_WHEN_USING_ERASE_FUNCTION_WITH_ALL   error_type;
  };

  template <>
  class data_erasor_with_key<all, all>
  {
    //force linker error here
  };
  
  template <typename KeyType,
            typename DataType>
  class data_erasor_no_key
  {
    public:
      data_erasor_no_key() {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el)
      {
        data_container<KeyType, DataType, ObjectType>::instance().erase(el);
      }
  };

  template <typename KeyType>
  class data_erasor_no_key <KeyType, all>
  {
    public:
      data_erasor_no_key() {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el)
      {
        key_value_registration<ObjectType>::instance().template erase_key_all<KeyType>(el);
      }
  };

  template <typename DataType>
  class data_erasor_no_key <all, DataType>
  {
    public:
      data_erasor_no_key() {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el)
      {
        key_value_registration<ObjectType>::instance().template erase_all_value<DataType>(el);
      }
  };
  
  template <>
  class data_erasor_no_key <all, all>
  {
    public:
      data_erasor_no_key() {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el)
      {
        key_value_registration<ObjectType>::instance().erase_all_all(el);
      }
  };
  
  template <typename KeyType,
            typename DataType>
  data_erasor_with_key<KeyType, DataType> erase(KeyType const & key)
  {
    return data_erasor_with_key<KeyType, DataType>(key);
  }

  template <typename KeyType>
  data_erasor_with_key<KeyType, typename config::default_data_for_key<KeyType>::type> erase(KeyType const & key)
  {
    return data_erasor_with_key<KeyType, typename config::default_data_for_key<KeyType>::type>(key);
  }

  template <typename KeyType,
            typename DataType>
  data_erasor_no_key<KeyType, DataType> erase()
  {
    return data_erasor_no_key<KeyType, DataType>();
  }

  template <typename KeyType>
  data_erasor_no_key<KeyType, typename config::default_data_for_key<KeyType>::type> erase()
  {
    return data_erasor_no_key<KeyType, typename config::default_data_for_key<KeyType>::type>();
  }

  
  

  template <typename KeyType,
            typename DataType>
  class data_copy_with_key
  {
    public:
      data_copy_with_key(KeyType const & key) : key_(key) {}
      
      template <typename ObjectSrcType,
                typename ObjectDestType>
      void operator()(ObjectSrcType const & el_src,
                      ObjectDestType const & el_dest)
      {
        access<KeyType, DataType>(key_)(el_dest) = access<KeyType, DataType>(key_)(el_src);
      }
    private:
      KeyType const & key_;
  };
  
  //prevent messing around with all-type and supplied key:
  template <typename KeyType>
  class data_copy_with_key<KeyType, all>
  {
    typedef typename error_indicator<KeyType>::ERROR_NO_KEY_ARGUMENT_ALLOWED_WHEN_USING_COPY_FUNCTION_WITH_ALL   error_type;
  };

  template <typename DataType>
  class data_copy_with_key<all, DataType>
  {
    typedef typename error_indicator<DataType>::ERROR_NO_KEY_ARGUMENT_ALLOWED_WHEN_USING_COPY_FUNCTION_WITH_ALL   error_type;
  };

  template <>
  class data_copy_with_key<all, all>
  {
    //force linker error here
  };
  
  template <typename KeyType,
            typename DataType>
  data_copy_with_key<KeyType, DataType> copy(KeyType const & key)
  {
    return data_copy_with_key<KeyType, DataType>(key);
  }

  template <typename KeyType>
  data_copy_with_key<KeyType, typename config::default_data_for_key<KeyType>::type> copy(KeyType const & key)
  {
    return data_copy_with_key<KeyType, typename config::default_data_for_key<KeyType>::type>(key);
  }

  
  template <typename KeyType,
            typename DataType>
  class data_copy_no_key
  {
    public:
      data_copy_no_key() {}
      
      template <typename object_src_type, typename object_dest_type>
      void operator()(object_src_type const & el_src, object_dest_type const & el_dest)
      {
        data_container<KeyType, DataType, object_src_type>::instance().copy(el_src, el_dest);
      }
  };
  
  template <typename KeyType>
  class data_copy_no_key <KeyType, all>
  {
    public:
      data_copy_no_key() {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el_src, ObjectType const & el_dest)
      {
        key_value_registration<ObjectType>::instance().template copy_key_all<KeyType>(el_src, el_dest);
      }
      
      template <typename object_src_type, typename object_dest_type>
      void operator()(object_src_type const & el_src, object_dest_type const & el_dest)
      {
        typedef typename error_indicator<object_src_type>::ERROR_SOURCE_AND_DESTINATION_MUST_BE_OF_SAME_TYPE_WHEN_USING_COPY_WITH_ALL  error_type;
      }
  };

  template <typename DataType>
  class data_copy_no_key <all, DataType>
  {
    public:
      data_copy_no_key() {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el_src,
                      ObjectType const & el_dest)
      {
        key_value_registration<ObjectType>::instance().template copy_all_value<DataType>(el_src, el_dest);
      }
      
      template <typename object_src_type,
                typename object_dest_type>
      void operator()(object_src_type const & el_src, object_dest_type const & el_dest)
      {
        typedef typename error_indicator<object_src_type>::ERROR_SOURCE_AND_DESTINATION_MUST_BE_OF_SAME_TYPE_WHEN_USING_COPY_WITH_ALL  error_type;
      }
  };
  
  template <>
  class data_copy_no_key <all, all>
  {
    public:
      data_copy_no_key() {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & el_src,
                      ObjectType const & el_dest)
      {
        key_value_registration<ObjectType>::instance().copy_all_all(el_src, el_dest);
      }
      
      template <typename object_src_type, typename object_dest_type>
      void operator()(object_src_type const & el_src,
                      object_dest_type const & el_dest)
      {
        typedef typename error_indicator<object_src_type>::ERROR_SOURCE_AND_DESTINATION_MUST_BE_OF_SAME_TYPE_WHEN_USING_COPY_WITH_ALL  error_type;
      }
  };
  
  
  
  template <typename KeyType, typename DataType>
  data_copy_no_key<KeyType, DataType> copy()
  {
    return data_copy_no_key<KeyType, DataType>();
  }
  
  template <typename KeyType>
  data_copy_no_key<KeyType, typename config::default_data_for_key<KeyType>::type> copy()
  {
    return data_copy_no_key<KeyType, typename config::default_data_for_key<KeyType>::type>();
  }



  template <typename KeyType,
            typename DataType>
  class data_mover_with_key
  {
    public:
      data_mover_with_key(KeyType const & key) : key_(key) {}
      
      template <typename ObjectSrcType,
                typename ObjectDestType>
      void operator()(ObjectSrcType const & el_src,
                      ObjectDestType const & el_dest)
      {
        //std::cout << "Get data from element" << std::endl;
        access<KeyType, DataType>(key_)(el_dest) = access<KeyType, DataType>(key_)(el_src);
        erase<KeyType, DataType>(key_)(el_src);
      }
    private:
      KeyType const & key_;
  };
  
  
  //prevent messing around with all-type and supplied key:
  template <typename KeyType>
  class data_mover_with_key<KeyType, all>
  {
    typedef typename error_indicator<KeyType>::ERROR_NO_KEY_ARGUMENT_ALLOWED_WHEN_USING_COPY_FUNCTION_WITH_ALL   error_type;
  };

  template <typename DataType>
  class data_mover_with_key<all, DataType>
  {
    typedef typename error_indicator<DataType>::ERROR_NO_KEY_ARGUMENT_ALLOWED_WHEN_USING_COPY_FUNCTION_WITH_ALL   error_type;
  };

  template <>
  class data_mover_with_key<all, all>
  {
    //force linker error here
  };
  
  
  template <typename KeyType,
            typename DataType>
  data_mover_with_key<KeyType, DataType> move(KeyType const & key)
  {
    return data_mover_with_key<KeyType, DataType>(key);
  }
  
  template <typename KeyType>
  data_mover_with_key<KeyType, typename config::default_data_for_key<KeyType>::type> move(KeyType const & key)
  {
    return data_mover_with_key<KeyType, typename config::default_data_for_key<KeyType>::type>(key);
  }


  template <typename KeyType,
            typename DataType>
  class data_mover_no_key
  {
    public:
      data_mover_no_key() {}
      
      template <typename object_src_type, typename object_dest_type>
      void operator()(object_src_type const & el_src, object_dest_type const & el_dest)
      {
        data_copy_no_key<KeyType, DataType>()(el_src, el_dest);
        data_erasor_no_key<KeyType, DataType>()(el_src);
      }
  };
  
  template <typename KeyType,
            typename DataType>
  data_mover_no_key<KeyType, DataType> move()
  {
    return data_mover_no_key<KeyType, DataType>();
  }
  
  template <typename KeyType>
  data_mover_no_key<KeyType, typename config::default_data_for_key<KeyType>::type> move()
  {
    return data_mover_no_key<KeyType, typename config::default_data_for_key<KeyType>::type>();
  }


  
  template <typename KeyType,
            typename DataType>
  class data_reservation_proxy
  {
    public:
      data_reservation_proxy(long num) : num_(num) {}
      
      template <typename ObjectType>
      void operator()(ObjectType const & e)
      {
        data_container<KeyType, DataType, ObjectType>::instance().reserve(num_);
      }
    
    private:
      long num_;
  };
  

  template <typename KeyType,
            typename DataType>
  data_reservation_proxy<KeyType, DataType> reserve(long num)
  {
    return data_reservation_proxy<KeyType, DataType>(num);
  }
  
  template <typename KeyType>
  data_reservation_proxy<KeyType, typename config::default_data_for_key<KeyType>::type> reserve(long num)
  {
    return data_reservation_proxy<KeyType, typename config::default_data_for_key<KeyType>::type>(num);
  }
  

  template <typename KeyType, typename DataType>
  class data_find_proxy_with_key
  {
    public:
      data_find_proxy_with_key(KeyType const & key) : key_(key) {}
      
      template <typename ObjectType>
      DataType * operator()(ObjectType const & el)
      {
        return data_container<KeyType, DataType, ObjectType>::instance().find(el, key_);
      }
    
    private:
      KeyType const & key_;
  };

  template <typename KeyType, typename DataType>
  data_find_proxy_with_key<KeyType, DataType> find(KeyType const & key)
  {
    return data_find_proxy_with_key<KeyType, DataType>(key);
  }

  template <typename KeyType>
  data_find_proxy_with_key<KeyType, typename config::default_data_for_key<KeyType>::type> find(KeyType const & key)
  {
    return data_find_proxy_with_key<KeyType, typename config::default_data_for_key<KeyType>::type>(key);
  }



  template <typename KeyType, typename DataType>
  class data_find_proxy_no_key
  {
    public:
      data_find_proxy_no_key() {}
      
      template <typename ObjectType>
      DataType * operator()(ObjectType const & el)
      {
        return data_container<KeyType, DataType, ObjectType>::instance().find(el);
      }
  };

  template <typename KeyType, typename DataType>
  data_find_proxy_no_key<KeyType, DataType> find()
  {
    return data_find_proxy_no_key<KeyType, DataType>();
  }

} //namespace viennadata


#endif