public function __construct($options = array()) { parent::__construct(); if (array_key_exists('lineend', $options)) { $this->setLineEnd($options['lineend']); } if (array_key_exists('charset', $options)) { $this->setCharset($options['charset']); } if (array_key_exists('language', $options)) { $this->setLanguage($options['language']); } if (array_key_exists('direction', $options)) { $this->setDirection($options['direction']); } if (array_key_exists('tab', $options)) { $this->setTab($options['tab']); } if (array_key_exists('link', $options)) { $this->setLink($options['link']); } if (array_key_exists('base', $options)) { $this->setBase($options['base']); } }
/** * * * @return MRange */ public function __construct($location, $length) { MAssertTypes('int', $location, 'int', $length); parent::__construct(); $this->location = $location; $this->length = $length; }
/** * Creates a new Persistent Store Coordinator instance * * @param MManagedObjectMode $mode The model to use for across the * different Persistent Stores * * @return MPersistentStoreCoordinator */ public function __construct(MManagedObjectModel $model) { parent::__construct(); $this->model = $model; $this->persistentStores = new MMutableSet(); $this->managedObjectContext = null; }
/** * Initializes a new instance of an MEntityDescriptionAttribute class * * @param MEntityDescription $entity The entity that this attribute belongs to * @param MString $name The attribute name * * @return MEntityDescriptionAttribute A new instance of the MEntityDescriptionAttribute class */ public function __construct(MEntityDescription $entity, MString $name) { parent::__construct(); $this->entity = $entity; $this->name = $name; $this->entity->addAttribute($this); }
/** * * * @return MView */ public function __construct() { parent::__construct(); $this->subviews = new MMutableArray(); $this->superview = null; $this->contentType = S("text/plain"); }
/** * Creates a new MApplicationControllerAcceptedMethod instance with the specified * method. * * @param MString $method A string containing the HTTP method this accepted method * represents * * @return MApplicationControllerAcceptedMethod The newly created acceted method * instance */ public function __construct(MString $method) { parent::__construct(); $this->method = $method; $this->contentTypes = new MMutableArray(); $this->fields = new MMutableArray(); }
/** * Constructs a new MPersistentStoreRequest instance. This method should be called * by all subclasses of MPersistentStoreRequest * * @see MPersistentStoreRequest::FetchRequestType * @see MPersistentStoreRequest::SaveRequestType * @see MPersistentStoreRequest::FaultRequestType * * @param int $requestType A constant defining the type of the request, possible * values are: * MPersistentStoreRequest::FetchRequestType * MPersistentStoreRequest::SaveRequestType * MPersistentStoreRequest::FaultRequestType * * @param MManagedObjectContext $context The context in which this Persistent Store * Request will be performed * * @return MPersistentStoreRequest The newly created instance of MPersistentStoreRequest */ public function __construct($requestType, MManagedObjectContext $context) { MAssertTypes('int', $requestType); parent::__construct(); $this->requestType = $requestType; $this->context = $context; }
/** * * @return MApplicationNode */ public function __construct(MString $name = null) { parent::__construct(); $this->name = $name ? $name : S(""); $this->parentNode = null; $this->childNodes = new MMutableArray(); }
/** * Creates a new MManagedObjectContext object that is connected to a Persistent Store Coordinator * * @param MPersistentStoreCoordinator $persistentStoreCoordinator The Persistent Store Coordinator * this context is connected to * * @return MManagedObjectContext The new Managed Object Context */ public function __construct(MPersistentStoreCoordinator $persistentStoreCoordinator) { parent::__construct(); $this->persistentStoreCoordinator = $persistentStoreCoordinator; $this->managedObjects = new MMutableArray(); $this->deletedObjects = new MMutableArray(); $this->persistentStoreCoordinator()->setManagedObjectContext($this); }
/** * Constructs a new Model by loading data from a model file * * @param MFile $file The file containing information about this model to be loaded * @param MString $version A String used to identify a specific version of the model * to use, if null is specified, the default version specified inside the model file * is used * * @return MManagedObjectModel The loaded Model instance */ public function __construct(MFile $modelFile, MString $version = null) { parent::__construct(); $this->modelFile = $modelFile; $this->version = $version; $this->entities = new MMutableArray(); $this->parse(); }
/** * This method should be overriden by subclasses of this class to perform * extra initialization as necessary * * This method initializes a new instance of a subclass of MApplicationControllerAttribute * with the specified name, type and required parameters * * @param MString $name The name of this attribute * @param int $type A constant representing the type of this attribute * Possible values are: * StringType * IntegerType * FloatType * BooleanType * DateType * BinaryType * ArrayType * DictionaryType * @param bool $required Wether or not this attribute is required */ public function __construct(MString $name, $type, $required = true) { MAssertTypes('int', $type, 'bool', $required); parent::__construct(); $this->name = $name; $this->type = $type; $this->required = $required; }
/** * * * @return MData */ public function __construct($bytes) { MAssertTypes('string', $bytes); parent::__construct(); if (!is_string($bytes)) { throw new MInvalidDataTypeException(S("string"), S(gettype($bytes))); } $this->bytes = $bytes; }
/** * * * @return MDictionary */ public function __construct($dictionary = array()) { parent::__construct(); $this->keys = new MMutableArray(A(array_keys($dictionary))); $this->values = new MMutableArray(A(array_values($dictionary))); $args = func_get_args(); if (N(count($args))->isEven()) { for ($i = 0; $i < count($args); $i++) { $key = $args[$i]; $object = $args[++$i]; $this->keys->addObject($key); $this->values->addObject($object); } } else { throw new MException(S("Uneven number of keys and objects specified")); } }
/** * * * @return MViewController */ public function __construct(MView $view = null) { parent::__construct(); $this->view = $view; $this->applicationController = null; $this->responseCode = MHTTPResponse::RESPONSE_OK; $this->responseHeaders = new MMutableDictionary(); $this->restricted = false; $this->realm = S("Restricted Area"); $this->accessDeniedView = null; $this->invalidCredentialsView = null; $this->authenticatedUserName = null; $this->parameterValues = null; $this->fieldValues = null; $this->parentViewController = null; $this->childViewControllers = new MMutableArray(); }
/** * * * @return MDate */ public function __construct($timestamp = null, $timeZone = null) { MAssertTypes('int', $timestamp, 'string', $timeZone); parent::__construct(); $this->timestamp = is_null($timestamp) ? time() : $timestamp; $this->timeZone = empty($timeZone) ? date_default_timezone_get() : $timeZone; }
/** * * * @return MStreamWriter */ public function __construct(MOutputStream $stream) { parent::__construct(); $this->stream = $stream; }
/** * Creates a new instance of the MPersistentStore class which represents a * Persistent Store identified by the Persistent Store url * * At the moment only MySQL is supported as a Persistent Store. In the future * support for other database mechanisms will be added * * The $url parameter currently uses the same format as PHP's PDO. * * @see http://php.net/manual/en/book.pdo.php * * @param MString $url A url which identifies your Persistent Store's location * This URL uses the same format used by PHP's PDO to connect to a database * @param MDictionary $options A Dictionary of options used to connect to the * Persistent Store * * @return MPersistentStore The newly created Persistent Store instance */ public function __construct(MString $url, MDictionary $options = null) { parent::__construct(); $this->url = $url; $this->options = $options; $this->username = S(""); $this->password = S(""); $this->delegate = null; $this->persistentStoreCoordinator = null; $this->connection = null; }
/** * * * @return MEnumerator */ public function __construct() { parent::__construct(); $this->reset(); }
/** * Creates a new MApplication instance with the specified delegate class * If no delegate class is specified the system looks for the 'manifest.xml' * file inside the 'resources' folder and parses it * * @param MString $delegateClass A string containing the fully qualified class * name for this application's delegate, or null. * * @return MApplication The MApplication instance which has just been created */ public function __construct(MString $delegateClass = null) { parent::__construct(); $this->_delegate = null; $this->_errorViewControllerClass = null; $this->_defaultNamespace = null; $this->_rootViewController = null; $this->_commandName = null; $this->_commandLineArguments = null; if (!$this->isRoutingEnabled()) { $this->enableRouting(); $redirect = new MHTTPResponse(MHTTPResponse::RESPONSE_FOUND); $redirect->addHeader(S("Location"), MHTTPRequest()->url()); MDie($redirect); } if ($delegateClass) { $this->_delegate = MObject::newInstanceOfClass($delegateClass); } else { if (MFile::fileExists("resources/manifest.xml")) { $xmlManifest = simplexml_load_file("resources/manifest.xml"); $this->_delegate = MObject::newInstanceOfClassWithParameters(S($xmlManifest['delegate']), A($this)); $this->_errorViewControllerClass = S($xmlManifest['errorClass']); try { $this->_defaultNamespace = MApplicationNamespace::parseFromXMLElement($xmlManifest, S("application")); } catch (Exception $e) { throw new MParseErrorException(S("resources/manifest.xml"), null, null, $e); } } else { $this->_delegate = new MApplicationDelegate($this); } } MApplication::$_application = $this; }
/** * * * @return MArray */ public function __construct($array = array()) { parent::__construct(); $this->array = $array; }
/** * * * @return MString */ public function __construct($string = "") { MAssertTypes('string', $string); parent::__construct(); $this->string = $string; }
/** * * * @return MSet */ public function __construct(MArray $array = null) { parent::__construct(); $this->set = $array ? $array->toArray() : array(); }
/** * * * @return MHTTPResponse */ public function __construct($code = MHTTPResponse::RESPONSE_OK, MString $body = null) { MAssertTypes('int', $code); parent::__construct(); $this->code = $code; $this->body = $body; $this->headers = new MMutableDictionary(); }
/** * @internal * * @return MHTTPRequest */ public function __construct($simulatedRequestFile = null, $simulatedRequestName = null) { parent::__construct(); $this->method = null; $this->contentType = null; $this->contents = null; $this->inputParameters = null; $this->inputFields = null; $this->arguments = null; $this->baseAddress = null; $this->relativeAddress = null; $this->baseUrl = null; $this->url = null; if ($simulatedRequestFile) { if (file_exists($simulatedRequestFile)) { $json = json_decode(file_get_contents($simulatedRequestFile), true); if (!empty($simulatedRequestName)) { $request = $json[$simulatedRequestName]; if (!empty($request)) { $this->server = array_merge($_SERVER, $json[$simulatedRequestName]['server']); $this->get = array_merge($_GET, $json[$simulatedRequestName]['get']); $this->post = array_merge($_POST, $json[$simulatedRequestName]['post']); $this->contentsFile = $json[$simulatedRequestName]['contents-file']; } else { throw new Exception(Sf("Could not find request named '%s' inside '%s'", $simulatedRequestName, $simulatedRequestFile)); } } else { throw new MException(S("You must specify a 'request_name'. Usage: hhvm -m index.php --simulated-request [json_request_file] [request_name]")); } } else { throw new MFileNotFoundException(S($simulatedRequestFile)); } } else { $this->server = $_SERVER; $this->get = $_GET; $this->post = $_POST; $this->contentsFile = "php://input"; } }
/** * * * @return MNumber */ public function __construct($number = 0) { parent::__construct(); if (!is_numeric($number)) { throw new MNaNException($number); } $this->number = $number; }
/** * * * @return MFile */ public function __construct(MString $path) { parent::__construct(); $this->path = $path; }
/** * Creates a new instance of an MEntityDescription object * * @example new MEntityDescription(S("Customer"), S("Customers"), S("com.myapp.Customer")); * * @see S() * * @param MString $name The entity name * @param MString $plural The entity's pluralised name * @param MString $entityClassName The fully qualified class name for the entity * * @return MEntityDescription The newly created instance of MEntityDescription */ public function __construct(MString $name, MString $plural, MString $entityClassName) { parent::__construct(); $this->name = $name; $this->plural = $plural; $this->entityClassName = $entityClassName; $this->attributes = new MMutableArray(); }
/** * Creates a new instance of the MManagedObject class and inserts it into the context * * @param MEntityDescription $entity The entity that represents this Managed Object * @param MManagedObjectContext $context The context to insert this new Managed Object into * * @return MManagedObject The newly created Managed Object */ public function __construct(MEntityDescription $entity, MManagedObjectContext $context, $objectID = MManagedObject::UNKNOWN_ID) { MAssertTypes('int', $objectID); parent::__construct(); $this->entity = $entity; $this->context = $context; $this->objectID = $objectID; $this->data = new MMutableDictionary(); $this->updatedData = new MMutableDictionary(); $this->relationships = new MMutableDictionary(); $this->insertedRelationships = new MMutableDictionary(); $this->removedRelationships = new MMutableDictionary(); $this->isSaving = false; $this->savingInsertedRelationships = new MMutableArray(); $this->savingRemovedRelationships = new MMutableArray(); $this->initDefaultValues(); $this->context()->insertObject($this); $this->didCreateObject(); }
/** * * * @return MStreamReader */ public function __construct(MInputStream $stream) { parent::__construct(); $this->stream = $stream; $this->buffer = new MMutableData(); }
/** * * * @return MStream */ public function __construct() { parent::__construct(); }