Configuration database

abstract class Conf {
	// All of the configuration variables we've loaded thus far
	protected $data;
 
	// The Wiki ID (usually $wgDBname)
	private $wikiId;
 
	// Singleton
	private static $__instance;
 
	protected function __construct( $conf ) {
		$this->config = $conf['id'];
	}
 
	/**
	 * Initialize a new child class based on a configuration array
	 * @param $conf Array of configuration settings, see $wgConfiguration
	 *   for details
	 * @return unknown_type
	 */
	private static function newFromSettings( $conf ) {
		$class = ucfirst( $conf['type'] ) . 'Conf';
		if( !class_exists( $class ) ) {
			throw new MWException( '$wgConf misconfigured with invalid "type"' );
		}
		return new $class( $conf );
	}
 
	/**
	 * Get the singleton if we don't want a specific wiki
	 * @param $wiki String An id for a remote wiki
	 * @return Conf child
	 */
	public static function load( $wiki = false ) {
		if( !self::$__instance ) {
			global $wgConfiguration;
			self::$__instance = self::newFromSettings( $wgConfiguration );
		} if( $wiki && $wiki != self::$__instace->getWikiId() ) {
			// Load configuration for a different wiki, not sure how
			// we're gonna do this yet
			return null;
		}
		return self::$__instance;
	}
 
	/**
	 * Get a property from the configuration database, falling back
	 * to DefaultSettings if undefined
	 * @param $key String Any possible configuration string
	 * @param $wiki String A wiki ID of a remote configuration [no-op]
	 * @return Mixed
	 */
	public static function get( $key, $wiki = false ) {
		return self::load( $wiki )->reallyGet( $key );
	}
 
	/**
	 * Set a property to the configuration database
	 * @param $key String Any possible configuration string
	 * @param $value Mixed Anything
	 * @param $write boolean If true, write to database
	 * @param $wiki String A wiki ID of a remote configuration [no-op]
	 * @return Boolean true on successful write
	 */
	public static function set( $key, $value, $write = false, $wiki = false ) {
		return self::load( $wiki )->reallySet( $key, $value, $write );
	}
 
	/**
	 * What is the wiki ID for this site?
	 * @return String
	 */
	public function getWikiId() {
		return $this->wikiId;
	}
 
	/**
	 * Actually retrieve the data. Check local var cache before
	 * trying the database and then default settings
	 * @param $key String a configuration key
	 * @return Mixed
	 */
	protected function reallyGet( $key ) {
		if( !isset( $this->data[$key] ) ) {
			$val = $this->retrieveSetting( $key );
			if( !$val ) {
				$val = DefaultSettings::$ds[$key];
			}
			$this->data[$key] = $this->stringToBoolean( $val );
		}
		return $this->data[$key];
	}
 
	/**
	 * Set the var to the local cache, then potentially to the database itself
	 * @param $key a configuration key
	 * @param $value Mixed
	 * @param $write Boolean true to write to the database, false for request-only
	 * @return unknown_type
	 */
	protected function reallySet( $key, $value, $write ) {
		if( count( $this->data ) > 100 ) {
			$this->data = array();
		}
		$this->data[$key] = $value;
		if( $write ) {
			return $this->applySetting( $key, $this->booleanToString( $value ) );
		}
		return true;
	}
 
	/**
	 * This is the implementation-specific part of the get() process.
	 * Child classes will need to implement this (eg: SQL queries, DBA
	 * calls, etc)
	 * @param $key String a configuration key
	 * @return Mixed
	 */
	abstract protected function retrieveSetting( $key );
 
	/**
	 * This is the implementation-specific part of the set() process.
	 * Child classes will need to implement this (eg: SQL queries, DBA
	 * calls, etc)
	 * @param $key String a configuration key
	 * @param $value Mixed
	 * @return Boolean success on write
	 */
	abstract protected function applySetting( $key, $value );
 
	/**
	 * Turn special-case 
	 * @return boolean (or original value, if not special-case)
	 */
	private function stringToBoolean( $v ) {
		if( $v === 'boolean-true' ) {
			return true;
		} elseif( $v === 'boolean-false' ) {
			return false;
		}
		return $v;
	}
 
	/**
	 * Munge a boolean into a string
	 * Some databases (like CDB) don't like storing non-strings.
	 * Since booleans are commonly used in configuration, we
	 * munge it to our 'boolean-true|false' strings.
	 * @param $v Mixed, anything to go in the database
	 * @return String (or original value, if not special-case)
	 */
	private function booleanToString( $v ) {
		if( is_boolean( $v ) ) {
			return $v ? 'boolean-true' : 'boolean-false';
		}
		return $v;
	}
}