[BACK]Return to pa_stylesheet_manager.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_stylesheet_manager.C between versions 1.16.2.4 and 1.23

version 1.16.2.4, 2003/02/21 08:50:03 version 1.23, 2003/12/11 09:22:09
Line 7 Line 7
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
 #ifdef XML  #ifdef XML
   
 static const char* IDENT_STYLESHEET_MANAGER_C="$Date$";  static const char * const IDENT_STYLESHEET_MANAGER_C="$Date$";
   
 #include "pa_stylesheet_manager.h"  #include "pa_stylesheet_manager.h"
 #include "pa_stylesheet_connection.h"  
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_threads.h"  #include "pa_threads.h"
Line 20  static const char* IDENT_STYLESHEET_MANA Line 19  static const char* IDENT_STYLESHEET_MANA
   
 // globals  // globals
   
 Stylesheet_manager *stylesheet_manager;  Stylesheet_manager* stylesheet_manager=0;
   
 // consts  // consts
   
 const int EXPIRE_UNUSED_CONNECTION_SECONDS=5*60;  const time_t SECOND=1;
 const int CHECK_EXPIRED_CONNECTION_SECONDS=EXPIRE_UNUSED_CONNECTION_SECONDS*2;  const time_t EXPIRE_UNUSED_CONNECTION_SECONDS=5*60;
   const time_t CHECK_EXPIRED_CONNECTION_SECONDS=EXPIRE_UNUSED_CONNECTION_SECONDS*2;
   
 // helpers  // helpers
   
 static void expire_connection(Array::Item *value, void *info) {  static void expire_connection(Stylesheet_connection& connection, time_t older_dies) {
         Stylesheet_connection& connection=*static_cast<Stylesheet_connection *>(value);  
         time_t older_dies=reinterpret_cast<time_t>(info);  
   
         if(connection.connected() && connection.expired(older_dies))          if(connection.connected() && connection.expired(older_dies))
                 connection.disconnect();                  connection.disconnect();
 }  }
 static void expire_connections(const Hash::Key& key, Hash::Val *value, void *info) {  static void expire_connections(
         Stack& stack=*static_cast<Stack *>(value);                                 Stylesheet_manager::connection_cache_type::key_type /*key*/, 
         for(int i=0; i<=stack.top_index(); i++)                                 Stylesheet_manager::connection_cache_type::value_type stack, 
                 expire_connection(stack.get(i), info);                                 time_t older_dies) {
           for(size_t i=0; i<stack->top_index(); i++)
                   expire_connection(*stack->get(i), older_dies);
 }  }
   
 // Stylesheet_manager  // Stylesheet_connection methods
   
 Stylesheet_manager::Stylesheet_manager(Pool& apool) : Cache_manager(apool),  void Stylesheet_connection::close() {
         connection_cache(apool),          stylesheet_manager.close_connection(ffile_spec, *this);
         prev_expiration_pass_time(0) {  
         }  
 Stylesheet_manager::~Stylesheet_manager() {  
         connection_cache.for_each(expire_connections,   
                 reinterpret_cast<void *>(time(0)+1/*=in future=expire all*/));  
 }  }
   
 Stylesheet_connection_ptr Stylesheet_manager::get_connection(const String& request_file_spec) {  // Stylesheet_manager methods
         Pool& pool=request_file_spec.pool(); // request pool                                                                                         
   
         // first trying to get cached stylesheet  Stylesheet_manager::Stylesheet_manager(): prev_expiration_pass_time(0) {
         Stylesheet_connection *connection=get_connection_from_cache(request_file_spec);  }
         if(!connection) {  
                 // then just construct it  
   
                 // make global_file_spec C-string on global pool  Stylesheet_manager::~Stylesheet_manager() {
                 CharPtr global_file_spec_cstr=request_file_spec.cstr(this->pool(pool), String::UL_FILE_SPEC);          connection_cache.for_each(expire_connections, time(0)+SECOND/*=in future=expire all*/);
                 // make global_file_spec string on global pool  }
                 String& global_file_spec=*new(this->pool()) String(this->pool(), global_file_spec_cstr);  
   
                 connection=new(this->pool()) Stylesheet_connection(this->pool(), global_file_spec);  Stylesheet_connection_ptr Stylesheet_manager::get_connection(String::Body file_spec) {
         }          Stylesheet_connection* result=get_connection_from_cache(file_spec);
         // associate with services[request]  (deassociates at close)          if(!result)
         connection->set_services(&pool);                   result=new Stylesheet_connection(file_spec);
         // return autoclosing object for it          return Stylesheet_connection_ptr(result);
         return Stylesheet_connection_ptr(connection);  
 }  }
   
 void Stylesheet_manager::close_connection(const String& file_spec,   void Stylesheet_manager::close_connection(String::Body file_spec, Stylesheet_connection& connection) {
                                                                                   Stylesheet_connection& connection) {  
         // deassociate from services[request]  
         connection.set_services(0);  
         put_connection_to_cache(file_spec, connection);          put_connection_to_cache(file_spec, connection);
 }  }
   
   
 // stylesheet cache  // stylesheet cache
 /// @todo get rid of memory spending Stack [zeros deep inside got accumulated]  /// @todo get rid of memory spending Stack [zeros deep inside got accumulated]
 Stylesheet_connection *Stylesheet_manager::get_connection_from_cache(const String& file_spec) {   Stylesheet_connection* Stylesheet_manager::get_connection_from_cache(String::Body file_spec) { 
         SYNCHRONIZED;          SYNCHRONIZED;
   
         if(Stack *connections=static_cast<Stack *>(connection_cache.get(file_spec)))          if(connection_cache_type::value_type connections=connection_cache.get(file_spec))
                 while(connections->top_index()>=0) { // there are cached stylesheets to that 'file_spec'                  while(!connections->is_empty()) { // there are cached stylesheets to that 'file_spec'
                         Stylesheet_connection *result=static_cast<Stylesheet_connection *>(connections->pop());                          Stylesheet_connection* result=connections->pop();
                         if(result->connected()) // not expired?                          if(result->connected()) // not expired?
                                 return result;                                  return result;
                 }                  }
Line 97  Stylesheet_connection *Stylesheet_manage Line 82  Stylesheet_connection *Stylesheet_manage
         return 0;          return 0;
 }  }
   
 void Stylesheet_manager::put_connection_to_cache(const String& file_spec,   void Stylesheet_manager::put_connection_to_cache(String::Body file_spec, 
                                                                                                  Stylesheet_connection& connection) {                                                    Stylesheet_connection& connection) { 
         SYNCHRONIZED;          SYNCHRONIZED;
   
         Stack *connections=static_cast<Stack *>(connection_cache.get(file_spec));          connection_cache_type::value_type connections=connection_cache.get(file_spec);
         if(!connections) { // there are no cached stylesheets to that 'file_spec' yet?          if(!connections) { // there are no cached stylesheets to that 'file_spec' yet?
                 connections=NEW Stack(pool()); // NOTE: never freed up!                  connections=new connection_cache_value_type;
                 connection_cache.put(file_spec, connections);                  connection_cache.put(file_spec, connections);
         }                 }       
         connections->push(&connection);          connections->push(&connection);
Line 113  void Stylesheet_manager::maybe_expire_ca Line 98  void Stylesheet_manager::maybe_expire_ca
         time_t now=time(0);          time_t now=time(0);
   
         if(prev_expiration_pass_time<now-CHECK_EXPIRED_CONNECTION_SECONDS) {          if(prev_expiration_pass_time<now-CHECK_EXPIRED_CONNECTION_SECONDS) {
                 connection_cache.for_each(expire_connections,                   connection_cache.for_each(expire_connections, now-EXPIRE_UNUSED_CONNECTION_SECONDS);
                         reinterpret_cast<void *>(now-EXPIRE_UNUSED_CONNECTION_SECONDS));  
   
                 prev_expiration_pass_time=now;                  prev_expiration_pass_time=now;
         }          }
 }  }
   
 static void add_connection_to_status_cache_table(Array::Item *value, void *info) {  static void add_connection_to_status_cache_table(Stylesheet_connection& connection, Table* table) {
         Stylesheet_connection& connection=*static_cast<Stylesheet_connection *>(value);  
         Table& table=*static_cast<Table *>(info);  
   
         if(connection.connected()) {          if(connection.connected()) {
                 Pool& pool=table.pool();                  ArrayString& row=*new ArrayString;
                 Array& row=*new(pool) Array(pool);  
   
                 // file                  // file
                 row+=&connection.file_spec();                  row+=new String(connection.file_spec(), String::L_AS_IS);
                 // time                  // time
                 time_t time_stamp=connection.get_time_used();                  time_t time_used=connection.get_time_used();
                 row+=new(pool) String(pool, pool.copy(ctime(&time_stamp)));                  row+=new String(pa_strdup(ctime(&time_used)));
   
                 table+=&row;                  *table+=&row;
         }          }
 }  }
 static void add_connections_to_status_cache_table(const Hash::Key& key, Hash::Val *value, void *info) {  static void add_connections_to_status_cache_table(
         Stack& stack=*static_cast<Stack *>(value);          Stylesheet_manager::connection_cache_type::key_type /*key*/, 
         Array_iter iter(stack);          Stylesheet_manager::connection_cache_type::value_type stack, Table* table) 
         for(int countdown=stack.top_index(); countdown-->=0; )  {
                 add_connection_to_status_cache_table(iter.next(), info);          for(Array_iterator<Stylesheet_connection*> i(*stack); i.has_next(); )
                   add_connection_to_status_cache_table(*i.next(), table);
 }  }
 Value& Stylesheet_manager::get_status(Pool& pool, const String *source) {  
         VHash& result=*new(pool) VHash(pool);  
   
   Value* Stylesheet_manager::get_status() {
           VHash* result=new VHash;
         // cache          // cache
         {          {
                 Array& columns=*new(pool) Array(pool);                  ArrayString& columns=*new ArrayString;
                 columns+=new(pool) String(pool, "file");                  columns+=new String("file");
                 columns+=new(pool) String(pool, "time");                  columns+=new String("time");
                 Table& table=*new(pool) Table(pool, 0, &columns, connection_cache.size());                  Table& table=*new Table(&columns, connection_cache.count());
   
                 connection_cache.for_each(add_connections_to_status_cache_table, &table);                  connection_cache.for_each(add_connections_to_status_cache_table, &table);
   
                 result.hash(source).put(*new(pool) String(pool, "cache"), new(pool) VTable(pool, &table));                  result->get_hash()->put(*new String("cache"), new VTable(&table));
         }          }
   
         return result;          return result;
 }  }
   
Removed from v.1.16.2.4  
changed lines
  Added in v.1.23

E-mail: