Documentation Overview Building ASL Documentation Library Wiki Docs Indices Browse Perforce More Info Release Notes Wiki Site Search License Success Stories Contributors Media Download Perforce Depots Support ASL SourceForge Home Mailing Lists Discussion Forums Report Bugs Suggest Features Contribute to ASL RSS Short-text news Full-text news File releases Other Adobe Projects Adobe Air Adobe GIL C++ Benchmarks Adobe Labs Adobe Media Gallery Adobe XMP Tamarin project (Mozilla Foundation) Other Resources Boost RIAForge SGI STL

sequence_model.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt or a copy at http://stlab.adobe.com/licenses.html) */ /******************************************************************************/ #ifndef ADOBE_SEQUENCE_MODEL_HPP #define ADOBE_SEQUENCE_MODEL_HPP /******************************************************************************/ #include <list> #ifdef ADOBE_STD_SERIALIZATION #include <iostream> #endif #include <boost/bind.hpp> #include <boost/next_prior.hpp> #include <boost/operators.hpp> #include <boost/static_assert.hpp> #include <adobe/algorithm/copy.hpp> #include <adobe/algorithm/find.hpp> #include <adobe/algorithm/for_each.hpp> #include <adobe/copy_on_write.hpp> #include <adobe/poly_sequence_controller.hpp> #include <adobe/poly_sequence_view.hpp> #include <adobe/poly_sequence_model.hpp> #include <adobe/sequence_model_fwd.hpp> #include <adobe/typeinfo.hpp> #include <adobe/vector.hpp> /******************************************************************************/ namespace adobe { /******************************************************************************/ template <typename T> class sequence_model { public: typedef T value_type; typedef std::size_t size_type; typedef copy_on_write<value_type> cow_value_type; typedef sequence_key<T> key_type; typedef typename poly_sequence_view<T>::type poly_sequence_view_type; typedef typename poly_sequence_controller<T>::type poly_sequence_controller_type; BOOST_STATIC_ASSERT((sizeof(key_type) == sizeof(void*))); static bool interface_requires_std_rtti() { return adobe::type_info<T>().requires_std_rtti(); } static cow_value_type at(key_type key) { return *key.value_m; } void push_back(const value_type& value) { storage_m.push_back(cow_value_type(value)); for_each(view_set_m, boost::bind(&poly_sequence_view_type::extend, _1, key_type::nkey, key_type(*--storage_m.end()), boost::cref(storage_m.back()))); } void set(key_type key, const value_type& value) { if (!is_valid(key)) return; storage_iterator iter(iterator_for(key)); *iter = cow_value_type(value); for_each(view_set_m, boost::bind(&poly_sequence_view_type::refresh, _1, key, boost::cref(*iter))); } void insert_set(key_type before, const vector<value_type>& value_set) { storage_iterator before_iterator(iterator_for(before)); vector<key_type> extend_key_set; for (typename vector<value_type>::const_iterator iter(value_set.begin()), last(value_set.end()); iter != last; ++iter) { storage_iterator result(storage_m.insert(before_iterator, cow_value_type(*iter))); extend_key_set.push_back(key_type(*result)); } for_each(view_set_m, boost::bind(&poly_sequence_view_type::extend_set, _1, before, extend_key_set)); } void insert(key_type before, const value_type& value) { storage_iterator result(storage_m.insert(iterator_for(before), cow_value_type(value))); for_each(view_set_m, boost::bind(&poly_sequence_view_type::extend, _1, before, key_type(*result), boost::cref(*result))); } void erase(const vector<key_type>& key_set) { typedef typename vector<key_type>::const_iterator const_iterator; for (const_iterator iter(key_set.begin()), last(key_set.end()); iter != last; ++iter) storage_m.erase(iterator_for(*iter)); for_each(view_set_m, boost::bind(&poly_sequence_view_type::erase, _1, boost::cref(key_set))); } void clear() { storage_m.clear(); for_each(view_set_m, boost::bind(&poly_sequence_view_type::clear, _1)); } void attach_view(poly_sequence_view_type& view); void detach_view(poly_sequence_view_type& view); void attach_controller(poly_sequence_controller_type& controller); void detach_controller(poly_sequence_controller_type& controller); private: #ifndef ADOBE_NO_DOCUMENTATION typedef std::list<cow_value_type> storage_type; typedef typename storage_type::iterator storage_iterator; static bool is_valid(key_type k) { return k != key_type::nkey; } size_type size() const { return storage_m.size(); } bool empty() const { return storage_m.empty(); } storage_iterator iterator_for(key_type key) const { storage_type& storage(const_cast<storage_type&>(storage_m)); if (!is_valid(key)) return storage.end(); // Ugh -- linear search through the list to find the key. // // REVISIT (fbrereto) : Is there any way to make this faster? Perhaps a // cache of some kind to binary-search the key set, // retrieving an iterator? Using table_index? for (storage_iterator iter(storage.begin()), last(storage.end()); iter != last; ++iter) if (key_type(*iter) == key) return iter; return storage.end(); } typedef vector<poly_sequence_view_type*> view_set_t; typedef vector<poly_sequence_controller_type*> controller_set_t; storage_type storage_m; view_set_t view_set_m; controller_set_t controller_set_m; auto_ptr<typename poly_sequence_model<T>::type> poly_m; // ADOBE_NO_DOCUMENTATION #endif }; /******************************************************************************/ template <typename T> void sequence_model<T>::attach_view(poly_sequence_view_type& view) { typename view_set_t::iterator found(adobe::find(view_set_m, &view)); if (found != view_set_m.end()) return; view_set_m.push_back(&view); view.clear(); if (empty()) return; // tell the view everything possible about the current state of the model vector<key_type> extend_key_set; for (storage_iterator iter(storage_m.begin()), last(storage_m.end()); iter != last; ++iter) extend_key_set.push_back(key_type(*iter)); view.extend_set(key_type::nkey, extend_key_set); } /******************************************************************************/ template <typename T> void sequence_model<T>::detach_view(poly_sequence_view_type& view) { typename view_set_t::iterator found(adobe::find(view_set_m, &view)); if (found == view_set_m.end()) return; view_set_m.erase(found); } /******************************************************************************/ template <typename T> void sequence_model<T>::attach_controller(poly_sequence_controller_type& controller) { typename controller_set_t::iterator found(adobe::find(controller_set_m, &controller)); if (found != controller_set_m.end()) return; controller_set_m.push_back(&controller); if (poly_m.get() == 0) poly_m.reset(new typename poly_sequence_model<T>::type(boost::ref(*this))); controller.monitor_sequence(*poly_m); } /******************************************************************************/ template <typename T> void sequence_model<T>::detach_controller(poly_sequence_controller_type& controller) { typename controller_set_t::iterator found(adobe::find(controller_set_m, &controller)); if (found == controller_set_m.end()) return; controller_set_m.erase(found); } /******************************************************************************/ } // namespace adobe /******************************************************************************/ // ADOBE_SEQUENCE_MODEL_HPP #endif /******************************************************************************/

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google