package net.sourceforge.blogentis.utils;
   
   //-----------------------------------------------------------------------
   //Blogentis - a blog publishing platform.
   //Copyright (C) 2004 Tassos Bassoukos <abassouk@gmail.com>
   //
   //This library is free software; you can redistribute it and/or
   //modify it under the terms of the GNU Lesser General Public
   //License as published by the Free Software Foundation; either
  //version 2.1 of the License, or (at your option) any later version.
  //
  //This library 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
  //Lesser General Public License for more details.
  //
  //You should have received a copy of the GNU Lesser General Public
  //License along with this library; if not, write to the Free Software
  //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  //-----------------------------------------------------------------------
  //
  //$Id: MappedConfiguration.java,v 1.2 2004/10/28 10:45:51 tassos Exp $
  //
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.sql.Connection;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import net.sourceforge.blogentis.om.BaseConfigurable;
  import net.sourceforge.blogentis.om.BaseConfigurablePeer;
  import net.sourceforge.blogentis.om.StoredBlogPeer;
  
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.configuration.BaseConfiguration;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.torque.TorqueException;
  import org.apache.torque.om.ObjectKey;
  import org.apache.torque.util.Transaction;
  
  /***
   * Class that keeps the configuration data of a blog in an in-memory HashMap.
   * 
   * @author abas
   */
  public class MappedConfiguration
          extends BaseConfiguration {
      private static final Log log = LogFactory.getLog(MappedConfiguration.class);
  
      protected BaseConfigurablePeer peer = null;
      protected ObjectKey primaryKey = null;
      protected boolean modified = false;
  
      protected void initFromBlog(BaseConfigurable obj)
              throws Exception {
          if (obj.getObjectData() == null)
              return;
          ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(
              obj.getObjectData()));
          Map map = (Map)ois.readObject();
          for(Iterator i = map.entrySet().iterator(); i.hasNext();) {
              Map.Entry e = (Entry)i.next();
              addProperty((String)e.getKey(), e.getValue());
          }
          modified = false;
      }
  
      public synchronized void saveTo(BaseConfigurable obj)
              throws IOException {
          if (obj.getPrimaryKey().compareTo(primaryKey) != 0
              || obj.getConfigurablePeer() != peer) {
              throw new IllegalArgumentException("Attempt to save to different object");
          }
          if (!modified)
              return;
          Map m = new HashMap();
          for(Iterator i = getKeys(); i.hasNext();) {
              String key = (String)i.next();
              Object o = getProperty(key);
              m.put(key, o);
          }
          ByteArrayOutputStream bos = new ByteArrayOutputStream(500);
          ObjectOutputStream oos = new ObjectOutputStream(bos);
          oos.writeObject(m);
          oos.close();
          obj.setObjectData(bos.toByteArray());
      }
  
      public synchronized void save()
             throws TorqueException {
         if (!modified)
             return;
         if (primaryKey == null)
             return; // FIXME: we need to be able to save the root properties.
         Connection con = null;
         try {
 
             con = Transaction.begin(StoredBlogPeer.DATABASE_NAME);
             BaseConfigurable obj = peer.getConfigurable(primaryKey, con);
             saveTo(obj);
             obj.save(con);
             Transaction.commit(con);
             modified = false;
         } catch (Exception e) {
             if (con != null)
                 Transaction.rollback(con);
             if (e instanceof TorqueException)
                 throw (TorqueException)e;
             throw new TorqueException("Could not save configuration", e);
         }
     }
 
     public MappedConfiguration(BaseConfigurable obj) {
         if (obj == null)
             return;
         primaryKey = obj.getPrimaryKey();
         peer = obj.getConfigurablePeer();
         try {
             initFromBlog(obj);
         } catch (Exception e) {
             log.error("Could not load prefs for " + primaryKey, e);
         }
     }
 
     protected void addPropertyDirect(String key, Object obj) {
         super.addPropertyDirect(key, obj);
         modified = true;
     }
 
     protected List processString(String token) {
         ArrayList l = new ArrayList(1);
         l.add(token);
         return l;
     }
 
     protected String interpolate(String base) {
         return base;
     }
 
     public void setList(String key, List cont) {
         setProperty(key, cont);
     }
 
     public String toString() {
         StringBuffer sb = new StringBuffer("MappedConfiguration (");
         sb.append(primaryKey);
         sb.append("/");
         sb.append(peer.getClass().getName());
         sb.append(") [\n");
         ArrayList l = new ArrayList();
         CollectionUtils.addAll(l, getKeys());
         Collections.sort(l);
         for(Iterator i = getKeys(); i.hasNext();) {
             String key = (String)i.next();
             sb.append(key);
             sb.append(" = ");
             sb.append(getPropertyDirect(key));
             sb.append("\n");
         }
         sb.append(']');
         return sb.toString();
     }
 
     public boolean isModified() {
         return modified;
     }
 }