+ * $acl->addRole(new \Phalcon\Acl\Role('administrator'), 'consultant');
+ * $acl->addRole('administrator', 'consultant');
+ *
+ *
+ * @param array|string accessInherits
+ */
+ public function addRole($role, $accessInherits=null){ }
+
+
+ /**
+ * Do a role inherit from another existing role
+ */
+ public function addInherit($roleName, $roleToInherit){ }
+
+
+ /**
+ * Check whether role exist in the roles list
+ */
+ public function isRole($roleName){ }
+
+
+ /**
+ * Check whether resource exist in the resources list
+ */
+ public function isResource($resourceName){ }
+
+
+ /**
+ * Adds a resource to the ACL list
+ *
+ * Access names can be a particular action, by example
+ * search, update, delete, etc or a list of them
+ *
+ * Example:
+ *
+ * //Add a resource to the the list allowing access to an action
+ * $acl->addResource(new \Phalcon\Acl\Resource('customers'), 'search');
+ * $acl->addResource('customers', 'search');
+ *
+ * //Add a resource with an access list
+ * $acl->addResource(new \Phalcon\Acl\Resource('customers'), array('create', 'search'));
+ * $acl->addResource('customers', array('create', 'search'));
+ *
+ *
+ * @param \Phalcon\Acl\Resource|string resourceValue
+ * @param array|string accessList
+ */
+ public function addResource($resourceValue, $accessList){ }
+
+
+ /**
+ * Adds access to resources
+ *
+ * @param array|string accessList
+ */
+ public function addResourceAccess($resourceName, $accessList){ }
+
+
+ /**
+ * Removes an access from a resource
+ *
+ * @param array|string accessList
+ */
+ public function dropResourceAccess($resourceName, $accessList){ }
+
+
+ /**
+ * Checks if a role has access to a resource
+ */
+ protected function _allowOrDeny($roleName, $resourceName, $access, $action){ }
+
+
+ /**
+ * Allow access to a role on a resource
+ *
+ * You can use '*' as wildcard
+ *
+ * Example:
+ *
+ * //Allow access to guests to search on customers
+ * $acl->allow('guests', 'customers', 'search');
+ *
+ * //Allow access to guests to search or create on customers
+ * $acl->allow('guests', 'customers', array('search', 'create'));
+ *
+ * //Allow access to any role to browse on products
+ * $acl->allow('*', 'products', 'browse');
+ *
+ * //Allow access to any role to browse on any resource
+ * $acl->allow('*', '*', 'browse');
+ *
+ */
+ public function allow($roleName, $resourceName, $access){ }
+
+
+ /**
+ * Deny access to a role on a resource
+ *
+ * You can use '*' as wildcard
+ *
+ * Example:
+ *
+ * //Deny access to guests to search on customers
+ * $acl->deny('guests', 'customers', 'search');
+ *
+ * //Deny access to guests to search or create on customers
+ * $acl->deny('guests', 'customers', array('search', 'create'));
+ *
+ * //Deny access to any role to browse on products
+ * $acl->deny('*', 'products', 'browse');
+ *
+ * //Deny access to any role to browse on any resource
+ * $acl->deny('*', '*', 'browse');
+ *
+ */
+ public function deny($roleName, $resourceName, $access){ }
+
+
+ /**
+ * Check whether a role is allowed to access an action from a resource
+ *
+ *
+ * //Does andres have access to the customers resource to create?
+ * $acl->isAllowed('andres', 'Products', 'create');
+ *
+ * //Do guests have access to any resource to edit?
+ * $acl->isAllowed('guests', '*', 'edit');
+ *
+ */
+ public function isAllowed($roleName, $resourceName, $access){ }
+
+
+ /**
+ * Return an array with every role registered in the list
+ */
+ public function getRoles(){ }
+
+
+ /**
+ * Return an array with every resource registered in the list
+ */
+ public function getResources(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Acl/AdapterInterface.php b/ide/2.0.2/Phalcon/Acl/AdapterInterface.php
new file mode 100644
index 000000000..77ea49532
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Acl/AdapterInterface.php
@@ -0,0 +1,58 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Apc();
+ *
+ */
+
+ class Apc extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface {
+
+ protected $_prefix;
+
+ protected $_ttl;
+
+ /**
+ * \Phalcon\Annotations\Adapter\Apc constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Reads parsed annotations from APC
+ *
+ * @param string key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key){ }
+
+
+ /**
+ * Writes parsed annotations to APC
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Annotations/Adapter/Files.php b/ide/2.0.2/Phalcon/Annotations/Adapter/Files.php
new file mode 100644
index 000000000..9cb389763
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Annotations/Adapter/Files.php
@@ -0,0 +1,44 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Files(array(
+ * 'annotationsDir' => 'app/cache/annotations/'
+ * ));
+ *
+ */
+
+ class Files extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface {
+
+ protected $_annotationsDir;
+
+ /**
+ * \Phalcon\Annotations\Adapter\Files constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Reads parsed annotations from files
+ *
+ * @param string key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key){ }
+
+
+ /**
+ * Writes parsed annotations to files
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Annotations/Adapter/Memory.php b/ide/2.0.2/Phalcon/Annotations/Adapter/Memory.php
new file mode 100644
index 000000000..5ba129622
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Annotations/Adapter/Memory.php
@@ -0,0 +1,30 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Xcache();
+ *
+ */
+
+ class Xcache extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface {
+
+ /**
+ * Reads parsed annotations from XCache
+ *
+ * @param string key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key){ }
+
+
+ /**
+ * Writes parsed annotations to XCache
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Annotations/AdapterInterface.php b/ide/2.0.2/Phalcon/Annotations/AdapterInterface.php
new file mode 100644
index 000000000..d98b06899
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Annotations/AdapterInterface.php
@@ -0,0 +1,28 @@
+
+ * //Traverse annotations
+ * foreach ($classAnnotations as $annotation) {
+ * echo 'Name=', $annotation->getName(), PHP_EOL;
+ * }
+ *
+ * //Check if the annotations has a specific
+ * var_dump($classAnnotations->has('Cacheable'));
+ *
+ * //Get an specific annotation in the collection
+ * $annotation = $classAnnotations->get('Cacheable');
+ *
+ */
+
+ class Collection implements \Iterator, \Traversable, \Countable {
+
+ protected $_position;
+
+ protected $_annotations;
+
+ /**
+ * \Phalcon\Annotations\Collection constructor
+ *
+ * @param array reflectionData
+ */
+ public function __construct($reflectionData=null){ }
+
+
+ /**
+ * Returns the number of annotations in the collection
+ */
+ public function count(){ }
+
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind(){ }
+
+
+ /**
+ * Returns the current annotation in the iterator
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function current(){ }
+
+
+ /**
+ * Returns the current position/key in the iterator
+ */
+ public function key(){ }
+
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next(){ }
+
+
+ /**
+ * Check if the current annotation in the iterator is valid
+ */
+ public function valid(){ }
+
+
+ /**
+ * Returns the internal annotations as an array
+ */
+ public function getAnnotations(){ }
+
+
+ /**
+ * Returns the first annotation that match a name
+ */
+ public function get($name){ }
+
+
+ /**
+ * Returns all the annotations that match a name
+ */
+ public function getAll($name){ }
+
+
+ /**
+ * Check if an annotation exists in a collection
+ */
+ public function has($name){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Annotations/Exception.php b/ide/2.0.2/Phalcon/Annotations/Exception.php
new file mode 100644
index 000000000..11e758b79
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Annotations/Exception.php
@@ -0,0 +1,7 @@
+
+ * //Parse the annotations in a class
+ * $reader = new \Phalcon\Annotations\Reader();
+ * $parsing = reader->parse('MyComponent');
+ *
+ * //Create the reflection
+ * $reflection = new \Phalcon\Annotations\Reflection($parsing);
+ *
+ * //Get the annotations in the class docblock
+ * $classAnnotations = reflection->getClassAnnotations();
+ *
+ */
+
+ class Reflection {
+
+ protected $_reflectionData;
+
+ protected $_classAnnotations;
+
+ protected $_methodAnnotations;
+
+ protected $_propertyAnnotations;
+
+ /**
+ * \Phalcon\Annotations\Reflection constructor
+ *
+ * @param array reflectionData
+ */
+ public function __construct($reflectionData=null){ }
+
+
+ /**
+ * Returns the annotations found in the class docblock
+ */
+ public function getClassAnnotations(){ }
+
+
+ /**
+ * Returns the annotations found in the methods' docblocks
+ *
+ * @return \Phalcon\Annotations\Collection[]
+ */
+ public function getMethodsAnnotations(){ }
+
+
+ /**
+ * Returns the annotations found in the properties' docblocks
+ *
+ * @return \Phalcon\Annotations\Collection[]
+ */
+ public function getPropertiesAnnotations(){ }
+
+
+ /**
+ * Returns the raw parsing intermediate definitions used to construct the reflection
+ *
+ * @return array
+ */
+ public function getReflectionData(){ }
+
+
+ /**
+ * Restores the state of a \Phalcon\Annotations\Reflection variable export
+ *
+ * @return array data
+ */
+ public static function __set_state($data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Assets/Collection.php b/ide/2.0.2/Phalcon/Assets/Collection.php
new file mode 100644
index 000000000..6b6006dc2
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Assets/Collection.php
@@ -0,0 +1,221 @@
+
+ * $inline = new \Phalcon\Assets\Inline('js', 'alert("hello world");');
+ *
+ */
+
+ class Inline {
+
+ protected $_type;
+
+ protected $_content;
+
+ protected $_filter;
+
+ protected $_attributes;
+
+ public function getType(){ }
+
+
+ public function getContent(){ }
+
+
+ public function getFilter(){ }
+
+
+ public function getAttributes(){ }
+
+
+ /**
+ * \Phalcon\Assets\Inline constructor
+ *
+ * @param string type
+ * @param string content
+ * @param boolean filter
+ * @param array attributes
+ */
+ public function __construct($type, $content, $filter=null, $attributes=null){ }
+
+
+ /**
+ * Sets the inline's type
+ */
+ public function setType($type){ }
+
+
+ /**
+ * Sets if the resource must be filtered or not
+ */
+ public function setFilter($filter){ }
+
+
+ /**
+ * Sets extra HTML attributes
+ */
+ public function setAttributes($attributes){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Assets/Inline/Css.php b/ide/2.0.2/Phalcon/Assets/Inline/Css.php
new file mode 100644
index 000000000..cc9cad9c0
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Assets/Inline/Css.php
@@ -0,0 +1,23 @@
+
+ * $assets->addCss('css/bootstrap.css');
+ * $assets->addCss('http://bootstrap.my-cdn.com/style.css', false);
+ *
+ *
+ * @param string path
+ * @param boolean local
+ * @param boolean filter
+ * @param array attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addCss($path, $local=null, $filter=null, $attributes=null){ }
+
+
+ /**
+ * Adds a inline Css to the 'css' collection
+ *
+ * @param string content
+ * @param boolean filter
+ * @param array attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addInlineCss($content, $filter=null, $attributes=null){ }
+
+
+ /**
+ * Adds a javascript resource to the 'js' collection
+ *
+ *
+ * $assets->addJs('scripts/jquery.js');
+ * $assets->addJs('http://jquery.my-cdn.com/jquery.js', false);
+ *
+ *
+ * @param string path
+ * @param boolean local
+ * @param boolean filter
+ * @param array attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addJs($path, $local=null, $filter=null, $attributes=null){ }
+
+
+ /**
+ * Adds a inline javascript to the 'js' collection
+ *
+ * @param string content
+ * @param boolean filter
+ * @param array attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addInlineJs($content, $filter=null, $attributes=null){ }
+
+
+ /**
+ * Adds a resource by its type
+ *
+ *
+ * $assets->addResourceByType('css', new \Phalcon\Assets\Resource\Css('css/style.css'));
+ *
+ */
+ public function addResourceByType($type, \Phalcon\Assets\Resource $resource){ }
+
+
+ /**
+ * Adds a inline code by its type
+ */
+ public function addInlineCodeByType($type, \Phalcon\Assets\Inline $code){ }
+
+
+ /**
+ * Adds a raw resource to the manager
+ *
+ *
+ * $assets->addResource(new \Phalcon\Assets\Resource('css', 'css/style.css'));
+ *
+ */
+ public function addResource(\Phalcon\Assets\Resource $resource){ }
+
+
+ /**
+ * Adds a raw inline code to the manager
+ */
+ public function addInlineCode(\Phalcon\Assets\Inline $code){ }
+
+
+ /**
+ * Sets a collection in the Assets Manager
+ *
+ *
+ * $assets->set('js', $collection);
+ *
+ */
+ public function set($id, \Phalcon\Assets\Collection $collection){ }
+
+
+ /**
+ * Returns a collection by its id
+ *
+ *
+ * $scripts = $assets->get('js');
+ *
+ */
+ public function get($id){ }
+
+
+ /**
+ * Returns the CSS collection of assets
+ */
+ public function getCss(){ }
+
+
+ /**
+ * Returns the CSS collection of assets
+ */
+ public function getJs(){ }
+
+
+ /**
+ * Creates/Returns a collection of resources
+ */
+ public function collection($name){ }
+
+
+ /**
+ * Traverses a collection calling the callback to generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection collection
+ * @param callback callback
+ * @param string type
+ */
+ public function output(\Phalcon\Assets\Collection $collection, $callback, $type){ }
+
+
+ /**
+ * Traverses a collection and generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection collection
+ * @param string type
+ */
+ public function outputInline(\Phalcon\Assets\Collection $collection, $type){ }
+
+
+ /**
+ * Prints the HTML for CSS resources
+ *
+ * @param string collectionName
+ */
+ public function outputCss($collectionName=null){ }
+
+
+ /**
+ * Prints the HTML for inline CSS
+ *
+ * @param string collectionName
+ */
+ public function outputInlineCss($collectionName=null){ }
+
+
+ /**
+ * Prints the HTML for JS resources
+ *
+ * @param string collectionName
+ */
+ public function outputJs($collectionName=null){ }
+
+
+ /**
+ * Prints the HTML for inline JS
+ *
+ * @param string collectionName
+ */
+ public function outputInlineJs($collectionName=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Assets/Resource.php b/ide/2.0.2/Phalcon/Assets/Resource.php
new file mode 100644
index 000000000..9941cc270
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Assets/Resource.php
@@ -0,0 +1,142 @@
+
+ * $resource = new \Phalcon\Assets\Resource('js', 'javascripts/jquery.js');
+ *
+ */
+
+ class Resource {
+
+ protected $_type;
+
+ protected $_path;
+
+ protected $_local;
+
+ protected $_filter;
+
+ protected $_attributes;
+
+ protected $_sourcePath;
+
+ protected $_targetPath;
+
+ protected $_targetUri;
+
+ public function getType(){ }
+
+
+ public function getPath(){ }
+
+
+ public function getLocal(){ }
+
+
+ public function getFilter(){ }
+
+
+ public function getAttributes(){ }
+
+
+ public function getSourcePath(){ }
+
+
+ public function getTargetPath(){ }
+
+
+ public function getTargetUri(){ }
+
+
+ /**
+ * \Phalcon\Assets\Resource constructor
+ *
+ * @param string type
+ * @param string path
+ * @param boolean local
+ * @param boolean filter
+ * @param array attributes
+ */
+ public function __construct($type, $path, $local=null, $filter=null, $attributes=null){ }
+
+
+ /**
+ * Sets the resource's type
+ */
+ public function setType($type){ }
+
+
+ /**
+ * Sets the resource's path
+ */
+ public function setPath($path){ }
+
+
+ /**
+ * Sets if the resource is local or external
+ */
+ public function setLocal($local){ }
+
+
+ /**
+ * Sets if the resource must be filtered or not
+ */
+ public function setFilter($filter){ }
+
+
+ /**
+ * Sets extra HTML attributes
+ */
+ public function setAttributes($attributes){ }
+
+
+ /**
+ * Sets a target uri for the generated HTML
+ */
+ public function setTargetUri($targetUri){ }
+
+
+ /**
+ * Sets the resource's source path
+ */
+ public function setSourcePath($sourcePath){ }
+
+
+ /**
+ * Sets the resource's target path
+ */
+ public function setTargetPath($targetPath){ }
+
+
+ /**
+ * Returns the content of the resource as an string
+ * Optionally a base path where the resource is located can be set
+ */
+ public function getContent($basePath=null){ }
+
+
+ /**
+ * Returns the real target uri for the generated HTML
+ */
+ public function getRealTargetUri(){ }
+
+
+ /**
+ * Returns the complete location where the resource is located
+ */
+ public function getRealSourcePath($basePath=null){ }
+
+
+ /**
+ * Returns the complete location where the resource must be written
+ */
+ public function getRealTargetPath($basePath=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Assets/Resource/Css.php b/ide/2.0.2/Phalcon/Assets/Resource/Css.php
new file mode 100644
index 000000000..084848bfd
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Assets/Resource/Css.php
@@ -0,0 +1,24 @@
+
+ * //Cache data for 2 days
+ * $frontCache = new \Phalcon\Cache\Frontend\Data(array(
+ * 'lifetime' => 172800
+ * ));
+ *
+ * $cache = new \Phalcon\Cache\Backend\Apc($frontCache, array(
+ * 'prefix' => 'app-data'
+ * ));
+ *
+ * //Cache arbitrary data
+ * $cache->save('my-data', array(1, 2, 3, 4, 5));
+ *
+ * //Get data
+ * $data = $cache->get('my-data');
+ *
+ *
+ */
+
+ class Apc extends \Phalcon\Cache\Backend implements \Phalcon\Cache\BackendInterface {
+
+ /**
+ * Returns a cached content
+ *
+ * @param string|long keyName
+ * @param long lifetime
+ * @return mixed
+ */
+ public function get($keyName, $lifetime=null){ }
+
+
+ /**
+ * Stores cached content into the APC backend and stops the frontend
+ *
+ * @param string|long keyName
+ * @param string content
+ * @param long lifetime
+ * @param boolean stopBuffer
+ */
+ public function save($keyName=null, $content=null, $lifetime=null, $stopBuffer=null){ }
+
+
+ /**
+ * Increment of a given key, by number $value
+ *
+ * @param string keyName
+ * @param long value
+ * @return mixed
+ */
+ public function increment($keyName=null, $value=null){ }
+
+
+ /**
+ * Decrement of a given key, by number $value
+ *
+ * @param string keyName
+ * @param long value
+ * @return mixed
+ */
+ public function decrement($keyName=null, $value=null){ }
+
+
+ /**
+ * Deletes a value from the cache by its key
+ */
+ public function delete($keyName){ }
+
+
+ /**
+ * Query the existing cached keys
+ *
+ * @param string prefix
+ * @return array
+ */
+ public function queryKeys($prefix=null){ }
+
+
+ /**
+ * Checks if cache exists and it hasn't expired
+ *
+ * @param string|long keyName
+ * @param long lifetime
+ * @return boolean
+ */
+ public function exists($keyName=null, $lifetime=null){ }
+
+
+ /**
+ * Immediately invalidates all existing items.
+ */
+ public function flush(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Cache/Backend/File.php b/ide/2.0.2/Phalcon/Cache/Backend/File.php
new file mode 100644
index 000000000..3c1bd4dad
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Cache/Backend/File.php
@@ -0,0 +1,139 @@
+
+ * //Cache the file for 2 days
+ * $frontendOptions = array(
+ * 'lifetime' => 172800
+ * );
+ *
+ * //Create a output cache
+ * $frontCache = \Phalcon\Cache\Frontend\Output($frontOptions);
+ *
+ * //Set the cache directory
+ * $backendOptions = array(
+ * 'cacheDir' => '../app/cache/'
+ * );
+ *
+ * //Create the File backend
+ * $cache = new \Phalcon\Cache\Backend\File($frontCache, $backendOptions);
+ *
+ * $content = $cache->start('my-cache');
+ * if ($content === null) {
+ * echo '
+ * application->addModules(array(
+ * 'admin' => array(
+ * 'className' => 'Multiple\Admin\Module',
+ * 'path' => '../apps/admin/Module.php'
+ * )
+ * ));
+ *
+ */
+ public function addModules($modules){ }
+
+
+ /**
+ * Return the modules registered in the console
+ */
+ public function getModules(){ }
+
+
+ /**
+ * Handle the whole command-line tasks
+ */
+ public function handle($arguments=null){ }
+
+
+ /**
+ * Set an specific argument
+ */
+ public function setArgument($arguments=null, $str=null, $shift=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Cli/Console/Exception.php b/ide/2.0.2/Phalcon/Cli/Console/Exception.php
new file mode 100644
index 000000000..26d9fbcbe
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Cli/Console/Exception.php
@@ -0,0 +1,7 @@
+
+ *
+ * $di = new \Phalcon\Di();
+ *
+ * $dispatcher = new \Phalcon\Cli\Dispatcher();
+ *
+ * $dispatcher->setDi(di);
+ *
+ * $dispatcher->setTaskName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ *
+ * $handle = dispatcher->dispatch();
+ *
+ *
+ */
+
+ class Dispatcher extends \Phalcon\Dispatcher implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\DispatcherInterface {
+
+ const EXCEPTION_NO_DI = 0;
+
+ const EXCEPTION_CYCLIC_ROUTING = 1;
+
+ const EXCEPTION_HANDLER_NOT_FOUND = 2;
+
+ const EXCEPTION_INVALID_HANDLER = 3;
+
+ const EXCEPTION_INVALID_PARAMS = 4;
+
+ const EXCEPTION_ACTION_NOT_FOUND = 5;
+
+ protected $_handlerSuffix;
+
+ protected $_defaultHandler;
+
+ protected $_defaultAction;
+
+ protected $_options;
+
+ /**
+ * \Phalcon\Cli\Dispatcher constructor
+ */
+ public function __construct(){ }
+
+
+ /**
+ * Sets the default task suffix
+ */
+ public function setTaskSuffix($taskSuffix){ }
+
+
+ /**
+ * Sets the default task name
+ */
+ public function setDefaultTask($taskName){ }
+
+
+ /**
+ * Sets the task name to be dispatched
+ */
+ public function setTaskName($taskName){ }
+
+
+ /**
+ * Gets last dispatched task name
+ */
+ public function getTaskName(){ }
+
+
+ /**
+ * Throws an internal exception
+ */
+ protected function _throwDispatchException($message, $exceptionCode=null){ }
+
+
+ /**
+ * Handles a user exception
+ */
+ protected function _handleException(\Exception $exception){ }
+
+
+ /**
+ * Returns the lastest dispatched controller
+ */
+ public function getLastTask(){ }
+
+
+ /**
+ * Returns the active task in the dispatcher
+ */
+ public function getActiveTask(){ }
+
+
+ /**
+ * Set the options to be dispatched
+ */
+ public function setOptions($options){ }
+
+
+ /**
+ * Get dispatched options
+ */
+ public function getOptions(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Cli/Dispatcher/Exception.php b/ide/2.0.2/Phalcon/Cli/Dispatcher/Exception.php
new file mode 100644
index 000000000..7f0b5f36f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Cli/Dispatcher/Exception.php
@@ -0,0 +1,7 @@
+Phalcon\Cli\Router is the standard framework router. Routing is the
+ * process of taking a command-line arguments and
+ * decomposing it into parameters to determine which module, task, and
+ * action of that task should receive the request
+ *
+ *
+ * $router = new \Phalcon\Cli\Router();
+ * $router->handle(array(
+ * 'module' => 'main',
+ * 'task' => 'videos',
+ * 'action' => 'process'
+ * ));
+ * echo $router->getTaskName();
+ *
+ *
+ */
+
+ class Router implements \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_module;
+
+ protected $_task;
+
+ protected $_action;
+
+ protected $_params;
+
+ protected $_defaultModule;
+
+ protected $_defaultTask;
+
+ protected $_defaultAction;
+
+ protected $_defaultParams;
+
+ protected $_routes;
+
+ protected $_matchedRoute;
+
+ protected $_matches;
+
+ protected $_wasMatched;
+
+ /**
+ * \Phalcon\Cli\Router constructor
+ */
+ public function __construct($defaultRoutes=null){ }
+
+
+ /**
+ * Sets the dependency injector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the internal dependency injector
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets the name of the default module
+ */
+ public function setDefaultModule($moduleName){ }
+
+
+ /**
+ * Sets the default controller name
+ */
+ public function setDefaultTask($taskName){ }
+
+
+ /**
+ * Sets the default action name
+ */
+ public function setDefaultAction($actionName){ }
+
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ */
+ public function setDefaults($defaults){ }
+
+
+ /**
+ * Handles routing information received from command-line arguments
+ *
+ * @param array arguments
+ */
+ public function handle($arguments=null){ }
+
+
+ /**
+ * Adds a route to the router
+ *
+ *
+ * $router->add('/about', 'About::main');
+ *
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function add($pattern, $paths=null){ }
+
+
+ /**
+ * Returns proccesed module name
+ */
+ public function getModuleName(){ }
+
+
+ /**
+ * Returns proccesed task name
+ */
+ public function getTaskName(){ }
+
+
+ /**
+ * Returns proccesed action name
+ */
+ public function getActionName(){ }
+
+
+ /**
+ * Returns proccesed extra params
+ *
+ * @return array
+ */
+ public function getParams(){ }
+
+
+ /**
+ * Returns the route that matchs the handled URI
+ */
+ public function getMatchedRoute(){ }
+
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches(){ }
+
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ */
+ public function wasMatched(){ }
+
+
+ /**
+ * Returns all the routes defined in the router
+ */
+ public function getRoutes(){ }
+
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param int id
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRouteById($id){ }
+
+
+ /**
+ * Returns a route object by its name
+ */
+ public function getRouteByName($name){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Cli/Router/Exception.php b/ide/2.0.2/Phalcon/Cli/Router/Exception.php
new file mode 100644
index 000000000..f28a53774
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Cli/Router/Exception.php
@@ -0,0 +1,7 @@
+
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ */
+ public function setName($name){ }
+
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callback callback
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function beforeMatch($callback){ }
+
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return mixed
+ */
+ public function getBeforeMatch(){ }
+
+
+ /**
+ * Returns the route's id
+ */
+ public function getRouteId(){ }
+
+
+ /**
+ * Returns the route's pattern
+ */
+ public function getPattern(){ }
+
+
+ /**
+ * Returns the route's compiled pattern
+ */
+ public function getCompiledPattern(){ }
+
+
+ /**
+ * Returns the paths
+ */
+ public function getPaths(){ }
+
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ */
+ public function getReversedPaths(){ }
+
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string name
+ * @param callable converter
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function convert($name, $converter){ }
+
+
+ /**
+ * Returns the router converter
+ */
+ public function getConverters(){ }
+
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset(){ }
+
+
+ /**
+ * Set the routing delimiter
+ */
+ public static function delimiter($delimiter=null){ }
+
+
+ /**
+ * Get routing delimiter
+ */
+ public static function getDelimiter(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Cli/Task.php b/ide/2.0.2/Phalcon/Cli/Task.php
new file mode 100644
index 000000000..240971cf8
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Cli/Task.php
@@ -0,0 +1,42 @@
+
+ *
+ *class HelloTask extends \Phalcon\Cli\Task
+ *{
+ *
+ * //This action will be executed by default
+ * public function mainAction()
+ * {
+ *
+ * }
+ *
+ * public function findAction()
+ * {
+ *
+ * }
+ *
+ *}
+ *
+ *
+ */
+
+ class Task extends \Phalcon\Di\Injectable implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ /**
+ * \Phalcon\Cli\Task constructor
+ */
+ final public function __construct(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Config.php b/ide/2.0.2/Phalcon/Config.php
new file mode 100644
index 000000000..a772bcf50
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Config.php
@@ -0,0 +1,144 @@
+
+ * $config = new \Phalcon\Config(array(
+ * "database" => array(
+ * "adapter" => "Mysql",
+ * "host" => "localhost",
+ * "username" => "scott",
+ * "password" => "cheetah",
+ * "dbname" => "test_db"
+ * ),
+ * "phalcon" => array(
+ * "controllersDir" => "../app/controllers/",
+ * "modelsDir" => "../app/models/",
+ * "viewsDir" => "../app/views/"
+ * )
+ * ));
+ *
+ *
+ */
+
+ class Config implements \ArrayAccess, \Countable {
+
+ /**
+ * \Phalcon\Config constructor
+ */
+ public function __construct($arrayConfig=null){ }
+
+
+ /**
+ * Allows to check whether an attribute is defined using the array-syntax
+ *
+ *
+ * var_dump(isset($config['database']));
+ *
+ */
+ public function offsetExists($index){ }
+
+
+ /**
+ * Gets an attribute from the configuration, if the attribute isn't defined returns null
+ * If the value is exactly null or is not defined the default value will be used instead
+ *
+ *
+ * echo $config->get('controllersDir', '../app/controllers/');
+ *
+ */
+ public function get($index, $defaultValue=null){ }
+
+
+ /**
+ * Gets an attribute using the array-syntax
+ *
+ *
+ * print_r($config['database']);
+ *
+ */
+ public function offsetGet($index){ }
+
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ *
+ * $config['database'] = array('type' => 'Sqlite');
+ *
+ */
+ public function offsetSet($index, $value){ }
+
+
+ /**
+ * Unsets an attribute using the array-syntax
+ *
+ *
+ * unset($config['database']);
+ *
+ */
+ public function offsetUnset($index){ }
+
+
+ /**
+ * Merges a configuration into the current one
+ *
+ *
+ * $appConfig = new \Phalcon\Config(array('database' => array('host' => 'localhost')));
+ * $globalConfig->merge($config2);
+ *
+ */
+ public function merge(\Phalcon\Config $config){ }
+
+
+ /**
+ * Converts recursively the object to an array
+ *
+ *
+ * print_r($config->toArray());
+ *
+ */
+ public function toArray(){ }
+
+
+ /**
+ * Returns the count of properties set in the config
+ *
+ *
+ * print count($config);
+ *
+ *
+ * or
+ *
+ *
+ * print $config->count();
+ *
+ */
+ public function count(){ }
+
+
+ /**
+ * Restores the state of a \Phalcon\Config object
+ */
+ public static function __set_state($data){ }
+
+
+ /**
+ * Helper method for merge configs (forwarding nested config instance)
+ *
+ * @param Config config
+ * @param Config instance = null
+ *
+ * @return Config merged config
+ */
+ final protected function _merge(\Phalcon\Config $config, $instance=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Config/Adapter/Ini.php b/ide/2.0.2/Phalcon/Config/Adapter/Ini.php
new file mode 100644
index 000000000..dce5fb4d2
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Config/Adapter/Ini.php
@@ -0,0 +1,66 @@
+
+ * [database]
+ * adapter = Mysql
+ * host = localhost
+ * username = scott
+ * password = cheetah
+ * dbname = test_db
+ *
+ * [phalcon]
+ * controllersDir = "../app/controllers/"
+ * modelsDir = "../app/models/"
+ * viewsDir = "../app/views/"
+ *
+ *
+ * You can read it as follows:
+ *
+ *
+ * $config = new Phalcon\Config\Adapter\Ini("path/config.ini");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+
+ class Ini extends \Phalcon\Config implements \Countable, \ArrayAccess {
+
+ /**
+ * \Phalcon\Config\Adapter\Ini constructor
+ */
+ public function __construct($filePath){ }
+
+
+ /**
+ * Build multidimensional array from string
+ *
+ *
+ * $this->_parseIniString('path.hello.world', 'value for last key');
+ *
+ * // result
+ * [
+ * 'path' => [
+ * 'hello' => [
+ * 'world' => 'value for last key',
+ * ],
+ * ],
+ * ];
+ *
+ * @param string path
+ * @param mixed value
+ *
+ * @return array parsed path
+ */
+ protected function _parseIniString($path, $value){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Config/Adapter/Json.php b/ide/2.0.2/Phalcon/Config/Adapter/Json.php
new file mode 100644
index 000000000..5d2351d08
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Config/Adapter/Json.php
@@ -0,0 +1,33 @@
+
+ * {"phalcon":{"baseuri":"\/phalcon\/"},"models":{"metadata":"memory"}}
+ *
+ *
+ * You can read it as follows:
+ *
+ *
+ * $config = new Phalcon\Config\Adapter\Json("path/config.json");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+
+ class Json extends \Phalcon\Config implements \Countable, \ArrayAccess {
+
+ /**
+ * \Phalcon\Config\Adapter\Json constructor
+ */
+ public function __construct($filePath){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Config/Adapter/Php.php b/ide/2.0.2/Phalcon/Config/Adapter/Php.php
new file mode 100644
index 000000000..32904aa86
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Config/Adapter/Php.php
@@ -0,0 +1,47 @@
+
+ * array(
+ * 'adapter' => 'Mysql',
+ * 'host' => 'localhost',
+ * 'username' => 'scott',
+ * 'password' => 'cheetah',
+ * 'dbname' => 'test_db'
+ * ),
+ *
+ * phalcon' => array(
+ * 'controllersDir' => '../app/controllers/',
+ * 'modelsDir' => '../app/models/',
+ * 'viewsDir' => '../app/views/'
+ *));
+ *
+ *
+ * You can read it as follows:
+ *
+ *
+ * $config = new Phalcon\Config\Adapter\Php("path/config.php");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+
+ class Php extends \Phalcon\Config implements \Countable, \ArrayAccess {
+
+ /**
+ * \Phalcon\Config\Adapter\Php constructor
+ */
+ public function __construct($filePath){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Config/Adapter/Yaml.php b/ide/2.0.2/Phalcon/Config/Adapter/Yaml.php
new file mode 100644
index 000000000..46a6b5e19
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Config/Adapter/Yaml.php
@@ -0,0 +1,39 @@
+
+ * phalcon
+ * baseuri: /phalcon/
+ * models:
+ * metadata: memory
+ *
+ *
+ * You can read it as follows:
+ *
+ *
+ * $config = new Phalcon\Config\Adapter\Yaml("path/config.yaml");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ *
+ */
+
+ class Yaml extends \Phalcon\Config implements \Countable, \ArrayAccess {
+
+ /**
+ * \Phalcon\Config\Adapter\Yaml constructor
+ *
+ * @throws \Phalcon\Config\Exception
+ */
+ public function __construct($filePath, $callbacks=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Config/Exception.php b/ide/2.0.2/Phalcon/Config/Exception.php
new file mode 100644
index 000000000..1df12f33a
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Config/Exception.php
@@ -0,0 +1,7 @@
+
+ * $crypt = new \Phalcon\Crypt();
+ *
+ * $key = 'le password';
+ * $text = 'This is a secret text';
+ *
+ * $encrypted = $crypt->encrypt($text, $key);
+ *
+ * echo $crypt->decrypt($encrypted, $key);
+ *
+ */
+
+ class Crypt implements \Phalcon\CryptInterface {
+
+ const PADDING_DEFAULT = 0;
+
+ const PADDING_ANSI_X_923 = 1;
+
+ const PADDING_PKCS7 = 2;
+
+ const PADDING_ISO_10126 = 3;
+
+ const PADDING_ISO_IEC_7816_4 = 4;
+
+ const PADDING_ZERO = 5;
+
+ const PADDING_SPACE = 6;
+
+ protected $_key;
+
+ protected $_padding;
+
+ protected $_mode;
+
+ protected $_cipher;
+
+ /**
+ * @brief \Phalcon\CryptInterface \Phalcon\Crypt::setPadding(int $scheme)
+ *
+ * @param int scheme Padding scheme
+ */
+ public function setPadding($scheme){ }
+
+
+ /**
+ * Sets the cipher algorithm
+ */
+ public function setCipher($cipher){ }
+
+
+ /**
+ * Returns the current cipher
+ */
+ public function getCipher(){ }
+
+
+ /**
+ * Sets the encrypt/decrypt mode
+ */
+ public function setMode($mode){ }
+
+
+ /**
+ * Returns the current encryption mode
+ */
+ public function getMode(){ }
+
+
+ /**
+ * Sets the encryption key
+ */
+ public function setKey($key){ }
+
+
+ /**
+ * Returns the encryption key
+ */
+ public function getKey(){ }
+
+
+ /**
+ * Adds padding @a padding_type to @a text
+ *
+ * @param return_value Result, possibly padded
+ * @param text Message to be padded
+ * @param mode Encryption mode; padding is applied only in CBC or ECB mode
+ * @param block_size Cipher block size
+ * @param padding_type Padding scheme
+ * @see http://www.di-mgt.com.au/cryptopad.html
+ */
+ protected function _cryptPadText($text, $mode, $blockSize, $paddingType){ }
+
+
+ /**
+ * Removes padding @a padding_type from @a text
+ * If the function detects that the text was not padded, it will return it unmodified
+ *
+ * @param return_value Result, possibly unpadded
+ * @param text Message to be unpadded
+ * @param mode Encryption mode; unpadding is applied only in CBC or ECB mode
+ * @param block_size Cipher block size
+ * @param padding_type Padding scheme
+ */
+ protected function _cryptUnpadText($text, $mode, $blockSize, $paddingType){ }
+
+
+ /**
+ * Encrypts a text
+ *
+ *
+ * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
+ *
+ */
+ public function encrypt($text, $key=null){ }
+
+
+ /**
+ * Decrypts an encrypted text
+ *
+ *
+ * echo $crypt->decrypt($encrypted, "decrypt password");
+ *
+ */
+ public function decrypt($text, $key=null){ }
+
+
+ /**
+ * Encrypts a text returning the result as a base64 string
+ */
+ public function encryptBase64($text, $key=null, $safe=null){ }
+
+
+ /**
+ * Decrypt a text that is coded as a base64 string
+ */
+ public function decryptBase64($text, $key=null, $safe=null){ }
+
+
+ /**
+ * Returns a list of available cyphers
+ */
+ public function getAvailableCiphers(){ }
+
+
+ /**
+ * Returns a list of available modes
+ */
+ public function getAvailableModes(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Crypt/Exception.php b/ide/2.0.2/Phalcon/Crypt/Exception.php
new file mode 100644
index 000000000..d52ab1e95
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Crypt/Exception.php
@@ -0,0 +1,7 @@
+
+ *
+ *try {
+ *
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306',
+ * ));
+ *
+ * $result = $connection->query("SELECT * FROM robots LIMIT 5");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetch()) {
+ * print_r($robot);
+ * }
+ *
+ *} catch (Phalcon\Db\Exception $e) {
+ * echo $e->getMessage(), PHP_EOL;
+ *}
+ *
+ *
+ */
+
+ abstract class Db {
+
+ const FETCH_LAZY = 1;
+
+ const FETCH_ASSOC = 2;
+
+ const FETCH_NAMED = 11;
+
+ const FETCH_NUM = 3;
+
+ const FETCH_BOTH = 4;
+
+ const FETCH_OBJ = 5;
+
+ const FETCH_BOUND = 6;
+
+ const FETCH_COLUMN = 7;
+
+ const FETCH_CLASS = 8;
+
+ const FETCH_INTO = 9;
+
+ const FETCH_FUNC = 10;
+
+ const FETCH_GROUP = 65536;
+
+ const FETCH_UNIQUE = 196608;
+
+ const FETCH_KEY_PAIR = 12;
+
+ const FETCH_CLASSTYPE = 262144;
+
+ const FETCH_SERIALIZE = 524288;
+
+ const FETCH_PROPS_LATE = 1048576;
+
+ /**
+ * Enables/disables options in the Database component
+ */
+ public static function setup($options){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Adapter.php b/ide/2.0.2/Phalcon/Db/Adapter.php
new file mode 100644
index 000000000..defd034c6
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Adapter.php
@@ -0,0 +1,594 @@
+
+ * //Getting first robot
+ * $robot = $connection->fecthOne("SELECT * FROM robots");
+ * print_r($robot);
+ *
+ * //Getting first robot with associative indexes only
+ * $robot = $connection->fecthOne("SELECT * FROM robots", \Phalcon\Db::FETCH_ASSOC);
+ * print_r($robot);
+ *
+ *
+ * @param string sqlQuery
+ * @param int fetchMode
+ * @param array bindParams
+ * @param array bindTypes
+ * @return array
+ */
+ public function fetchOne($sqlQuery, $fetchMode=null, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Dumps the complete result of a query into an array
+ *
+ *
+ * //Getting all robots with associative indexes only
+ * $robots = $connection->fetchAll("SELECT * FROM robots", \Phalcon\Db::FETCH_ASSOC);
+ * foreach ($robots as $robot) {
+ * print_r($robot);
+ * }
+ *
+ * //Getting all robots that contains word "robot" withing the name
+ * $robots = $connection->fetchAll("SELECT * FROM robots WHERE name LIKE :name",
+ * Phalcon\Db::FETCH_ASSOC,
+ * array('name' => '%robot%')
+ * );
+ * foreach($robots as $robot){
+ * print_r($robot);
+ * }
+ *
+ *
+ * @param string sqlQuery
+ * @param int fetchMode
+ * @param array bindParams
+ * @param array bindTypes
+ * @return array
+ */
+ public function fetchAll($sqlQuery, $fetchMode=null, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Returns the n'th field of first row in a SQL query result
+ *
+ *
+ * //Getting count of robots
+ * $robotsCount = $connection->fetchColumn("SELECT count(*) FROM robots");
+ * print_r($robotsCount);
+ *
+ * //Getting name of last edited robot
+ * $robot = $connection->fetchColumn("SELECT id, name FROM robots order by modified desc");
+ * print_r($robot);
+ *
+ *
+ * @param string sqlQuery
+ * @param array placeholders
+ * @param int|string column
+ * @return string|
+ */
+ public function fetchColumn($sqlQuery, $placeholders=null, $column=null){ }
+
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ *
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ *
+ * //Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param string|array table
+ * @param array values
+ * @param array fields
+ * @param array dataTypes
+ * @return boolean
+ */
+ public function insert($table, $values, $fields=null, $dataTypes=null){ }
+
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ * Another, more convenient syntax
+ *
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array(
+ * "name" => "Astro Boy",
+ * "year" => 1952
+ * )
+ * );
+ *
+ * //Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param string table
+ * @param array data
+ * @param array dataTypes
+ * @return boolean
+ */
+ public function insertAsDict($table, $data, $dataTypes=null){ }
+
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ *
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * "id = 101"
+ * );
+ *
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ *
+ * //Updating existing robot with array condition and $dataTypes
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * array(
+ * 'conditions' => "id = ?",
+ * 'bind' => array($some_unsafe_id),
+ * 'bindTypes' => array(PDO::PARAM_INT) //use only if you use $dataTypes param
+ * ),
+ * array(PDO::PARAM_STR)
+ * );
+ *
+ *
+ *
+ * Warning! If $whereCondition is string it not escaped.
+ *
+ * @param string|array table
+ * @param array fields
+ * @param array values
+ * @param string|array whereCondition
+ * @param array dataTypes
+ * @return boolean
+ */
+ public function update($table, $fields, $values, $whereCondition=null, $dataTypes=null){ }
+
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ * Another, more convenient syntax
+ *
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array(
+ * "name" => "New Astro Boy"
+ * ),
+ * "id = 101"
+ * );
+ *
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ *
+ *
+ * @param string table
+ * @param array data
+ * @param string whereCondition
+ * @param array dataTypes
+ * @return boolean
+ */
+ public function updateAsDict($table, $data, $whereCondition=null, $dataTypes=null){ }
+
+
+ /**
+ * Deletes data from a table using custom RBDM SQL syntax
+ *
+ *
+ * //Deleting existing robot
+ * $success = $connection->delete(
+ * "robots",
+ * "id = 101"
+ * );
+ *
+ * //Next SQL sentence is generated
+ * DELETE FROM `robots` WHERE `id` = 101
+ *
+ *
+ * @param string|array table
+ * @param string whereCondition
+ * @param array placeholders
+ * @param array dataTypes
+ * @return boolean
+ */
+ public function delete($table, $whereCondition=null, $placeholders=null, $dataTypes=null){ }
+
+
+ /**
+ * Gets a list of columns
+ *
+ * @param array columnList
+ * @return string
+ */
+ public function getColumnList($columnList){ }
+
+
+ /**
+ * Appends a LIMIT clause to $sqlQuery argument
+ *
+ *
+ * echo $connection->limit("SELECT * FROM robots", 5);
+ *
+ */
+ public function limit($sqlQuery, $number){ }
+
+
+ /**
+ * Generates SQL checking for the existence of a schema.table
+ *
+ *
+ * var_dump($connection->tableExists("blog", "posts"));
+ *
+ */
+ public function tableExists($tableName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ *
+ * var_dump($connection->viewExists("active_users", "posts"));
+ *
+ */
+ public function viewExists($viewName, $schemaName=null){ }
+
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ */
+ public function forUpdate($sqlQuery){ }
+
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ */
+ public function sharedLock($sqlQuery){ }
+
+
+ /**
+ * Creates a table
+ */
+ public function createTable($tableName, $schemaName, $definition){ }
+
+
+ /**
+ * Drops a table from a schema/database
+ */
+ public function dropTable($tableName, $schemaName=null, $ifExists=null){ }
+
+
+ /**
+ * Creates a view
+ *
+ * @param string tableName
+ * @param array definition
+ * @param string schemaName
+ * @return boolean
+ */
+ public function createView($viewName, $definition, $schemaName=null){ }
+
+
+ /**
+ * Drops a view
+ */
+ public function dropView($viewName, $schemaName=null, $ifExists=null){ }
+
+
+ /**
+ * Adds a column to a table
+ */
+ public function addColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column){ }
+
+
+ /**
+ * Modifies a table column based on a definition
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn=null){ }
+
+
+ /**
+ * Drops a column from a table
+ */
+ public function dropColumn($tableName, $schemaName, $columnName){ }
+
+
+ /**
+ * Adds an index to a table
+ */
+ public function addIndex($tableName, $schemaName, \Phalcon\Db\IndexInterface $index){ }
+
+
+ /**
+ * Drop an index from a table
+ */
+ public function dropIndex($tableName, $schemaName, $indexName){ }
+
+
+ /**
+ * Adds a primary key to a table
+ */
+ public function addPrimaryKey($tableName, $schemaName, \Phalcon\Db\IndexInterface $index){ }
+
+
+ /**
+ * Drops a table's primary key
+ */
+ public function dropPrimaryKey($tableName, $schemaName){ }
+
+
+ /**
+ * Adds a foreign key to a table
+ */
+ public function addForeignKey($tableName, $schemaName, \Phalcon\Db\ReferenceInterface $reference){ }
+
+
+ /**
+ * Drops a foreign key from a table
+ */
+ public function dropForeignKey($tableName, $schemaName, $referenceName){ }
+
+
+ /**
+ * Returns the SQL column definition from a column
+ */
+ public function getColumnDefinition(\Phalcon\Db\ColumnInterface $column){ }
+
+
+ /**
+ * List all tables on a database
+ *
+ *
+ * print_r($connection->listTables("blog"));
+ *
+ */
+ public function listTables($schemaName=null){ }
+
+
+ /**
+ * List all views on a database
+ *
+ *
+ * print_r($connection->listViews("blog"));
+ *
+ */
+ public function listViews($schemaName=null){ }
+
+
+ /**
+ * Lists table indexes
+ *
+ *
+ * print_r($connection->describeIndexes('robots_parts'));
+ *
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\Index[]
+ */
+ public function describeIndexes($table, $schema=null){ }
+
+
+ /**
+ * Lists table references
+ *
+ *
+ * print_r($connection->describeReferences('robots_parts'));
+ *
+ */
+ public function describeReferences($table, $schema=null){ }
+
+
+ /**
+ * Gets creation options from a table
+ *
+ *
+ * print_r($connection->tableOptions('robots'));
+ *
+ */
+ public function tableOptions($tableName, $schemaName=null){ }
+
+
+ /**
+ * Creates a new savepoint
+ */
+ public function createSavepoint($name){ }
+
+
+ /**
+ * Releases given savepoint
+ */
+ public function releaseSavepoint($name){ }
+
+
+ /**
+ * Rollbacks given savepoint
+ */
+ public function rollbackSavepoint($name){ }
+
+
+ /**
+ * Set if nested transactions should use savepoints
+ */
+ public function setNestedTransactionsWithSavepoints($nestedTransactionsWithSavepoints){ }
+
+
+ /**
+ * Returns if nested transactions should use savepoints
+ */
+ public function isNestedTransactionsWithSavepoints(){ }
+
+
+ /**
+ * Returns the savepoint name to use for nested transactions
+ */
+ public function getNestedTransactionSavepointName(){ }
+
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ */
+ public function getDefaultIdValue(){ }
+
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ */
+ public function supportSequences(){ }
+
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ */
+ public function useExplicitIdValue(){ }
+
+
+ /**
+ * Return descriptor used to connect to the active database
+ *
+ * @return array
+ */
+ public function getDescriptor(){ }
+
+
+ /**
+ * Gets the active connection unique identifier
+ *
+ * @return string
+ */
+ public function getConnectionId(){ }
+
+
+ /**
+ * Active SQL statement in the object
+ */
+ public function getSQLStatement(){ }
+
+
+ /**
+ * Active SQL statement in the object without replace bound paramters
+ */
+ public function getRealSQLStatement(){ }
+
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return array
+ */
+ public function getSQLBindTypes(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Adapter/Pdo.php b/ide/2.0.2/Phalcon/Db/Adapter/Pdo.php
new file mode 100644
index 000000000..4c3384145
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Adapter/Pdo.php
@@ -0,0 +1,241 @@
+
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306'
+ * ));
+ *
+ */
+
+ abstract class Pdo extends \Phalcon\Db\Adapter implements \Phalcon\Events\EventsAwareInterface {
+
+ protected $_pdo;
+
+ protected $_affectedRows;
+
+ /**
+ * Constructor for \Phalcon\Db\Adapter\Pdo
+ */
+ public function __construct($descriptor){ }
+
+
+ /**
+ * This method is automatically called in \Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection
+ *
+ *
+ * //Make a connection
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * ));
+ *
+ * //Reconnect
+ * $connection->connect();
+ *
+ *
+ * @param array descriptor
+ * @return boolean
+ */
+ public function connect($descriptor=null){ }
+
+
+ /**
+ * Returns a PDO prepared statement to be executed with 'executePrepared'
+ *
+ *
+ * $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ */
+ public function prepare($sqlStatement){ }
+
+
+ /**
+ * Executes a prepared statement binding. This function uses integer indexes starting from zero
+ *
+ *
+ * $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param \PDOStatement statement
+ * @param array placeholders
+ * @param array dataTypes
+ * @return \PDOStatement
+ */
+ public function executePrepared(\PDOStatement $statement, $placeholders, $dataTypes){ }
+
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server is returning rows
+ *
+ *
+ * //Querying data
+ * $resultset = $connection->query("SELECT * FROM robots WHERE type='mechanical'");
+ * $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical"));
+ *
+ *
+ * @param string sqlStatement
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Db\ResultInterface|bool
+ */
+ public function query($sqlStatement, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server doesn't return any rows
+ *
+ *
+ * //Inserting data
+ * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
+ * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
+ *
+ *
+ * @param string sqlStatement
+ * @param array bindParams
+ * @param array bindTypes
+ * @return boolean
+ */
+ public function execute($sqlStatement, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Returns the number of affected rows by the lastest INSERT/UPDATE/DELETE executed in the database system
+ *
+ *
+ * $connection->execute("DELETE FROM robots");
+ * echo $connection->affectedRows(), ' were deleted';
+ *
+ */
+ public function affectedRows(){ }
+
+
+ /**
+ * Closes the active connection returning success. \Phalcon automatically closes and destroys
+ * active connections when the request ends
+ */
+ public function close(){ }
+
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ *
+ * $escapedTable = $connection->escapeIdentifier('robots');
+ * $escapedTable = $connection->escapeIdentifier(array('store', 'robots'));
+ *
+ *
+ * @param string identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier){ }
+
+
+ /**
+ * Escapes a value to avoid SQL injections according to the active charset in the connection
+ *
+ *
+ * $escapedStr = $connection->escapeString('some dangerous value');
+ *
+ */
+ public function escapeString($str){ }
+
+
+ /**
+ * Converts bound parameters such as :name: or ?1 into PDO bind params ?
+ *
+ *
+ * print_r($connection->convertBoundParams('SELECT * FROM robots WHERE name = :name:', array('Bender')));
+ *
+ */
+ public function convertBoundParams($sql, $params=null){ }
+
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ *
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string sequenceName
+ * @return int|boolean
+ */
+ public function lastInsertId($sequenceName=null){ }
+
+
+ /**
+ * Starts a transaction in the connection
+ */
+ public function begin($nesting=null){ }
+
+
+ /**
+ * Rollbacks the active transaction in the connection
+ */
+ public function rollback($nesting=null){ }
+
+
+ /**
+ * Commits the active transaction in the connection
+ */
+ public function commit($nesting=null){ }
+
+
+ /**
+ * Returns the current transaction nesting level
+ */
+ public function getTransactionLevel(){ }
+
+
+ /**
+ * Checks whether the connection is under a transaction
+ *
+ *
+ * $connection->begin();
+ * var_dump($connection->isUnderTransaction()); //true
+ *
+ */
+ public function isUnderTransaction(){ }
+
+
+ /**
+ * Return internal PDO handler
+ */
+ public function getInternalHandler(){ }
+
+
+ /**
+ * Return the error info, if any
+ *
+ * @return array
+ */
+ public function getErrorInfo(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Mysql.php b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Mysql.php
new file mode 100644
index 000000000..e42f84642
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Mysql.php
@@ -0,0 +1,50 @@
+
+ *
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "port" => 3306,
+ * "username" => "sigma",
+ * "password" => "secret"
+ * );
+ *
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql($config);
+ *
+ *
+ */
+
+ class Mysql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Db\AdapterInterface {
+
+ protected $_type;
+
+ protected $_dialectType;
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * @param string|array identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier){ }
+
+
+ /**
+ * Returns an array of \Phalcon\Db\Column objects describing a table
+ *
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ */
+ public function describeColumns($table, $schema=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Oracle.php b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Oracle.php
new file mode 100644
index 000000000..5c93a7f3c
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Oracle.php
@@ -0,0 +1,82 @@
+
+ *
+ * $config = array(
+ * "dbname" => "//localhost/dbname",
+ * "username" => "oracle",
+ * "password" => "oracle"
+ * );
+ *
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Oracle($config);
+ *
+ *
+ */
+
+ class Oracle extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Db\AdapterInterface {
+
+ protected $_type;
+
+ protected $_dialectType;
+
+ /**
+ * This method is automatically called in \Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param array descriptor
+ * @return boolean
+ */
+ public function connect($descriptor=null){ }
+
+
+ /**
+ * Returns an array of \Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts")); ?>
+ */
+ public function describeColumns($table, $schema=null){ }
+
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ *
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ */
+ public function lastInsertId($sequenceName=null){ }
+
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ */
+ public function useExplicitIdValue(){ }
+
+
+ /**
+ * Return the default identity value to insert in an identity column
+ */
+ public function getDefaultIdValue(){ }
+
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ */
+ public function supportSequences(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Postgresql.php b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Postgresql.php
new file mode 100644
index 000000000..be04bde56
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Postgresql.php
@@ -0,0 +1,88 @@
+
+ *
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "username" => "postgres",
+ * "password" => ""
+ * );
+ *
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Postgresql($config);
+ *
+ *
+ */
+
+ class Postgresql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Db\AdapterInterface {
+
+ protected $_type;
+
+ protected $_dialectType;
+
+ /**
+ * This method is automatically called in \Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param array $descriptor
+ * @return boolean
+ */
+ public function connect($descriptor=null){ }
+
+
+ /**
+ * Returns an array of \Phalcon\Db\Column objects describing a table
+ *
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ */
+ public function describeColumns($table, $schema=null){ }
+
+
+ /**
+ * Creates a table
+ */
+ public function createTable($tableName, $schemaName, $definition){ }
+
+
+ /**
+ * Modifies a table column based on a definition
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn=null){ }
+
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ */
+ public function useExplicitIdValue(){ }
+
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ */
+ public function getDefaultIdValue(){ }
+
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ */
+ public function supportSequences(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Sqlite.php b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Sqlite.php
new file mode 100644
index 000000000..135adf20f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Adapter/Pdo/Sqlite.php
@@ -0,0 +1,72 @@
+
+ *
+ * $config = array(
+ * "dbname" => "/tmp/test.sqlite"
+ * );
+ *
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Sqlite($config);
+ *
+ *
+ */
+
+ class Sqlite extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Db\AdapterInterface {
+
+ protected $_type;
+
+ protected $_dialectType;
+
+ /**
+ * This method is automatically called in \Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param array $descriptor
+ * @return boolean
+ */
+ public function connect($descriptor=null){ }
+
+
+ /**
+ * Returns an array of \Phalcon\Db\Column objects describing a table
+ *
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ */
+ public function describeColumns($table, $schema=null){ }
+
+
+ /**
+ * Lists table indexes
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\IndexInterface[]
+ */
+ public function describeIndexes($table, $schema=null){ }
+
+
+ /**
+ * Lists table references
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\ReferenceInterface[]
+ */
+ public function describeReferences($table, $schema=null){ }
+
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ */
+ public function useExplicitIdValue(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/AdapterInterface.php b/ide/2.0.2/Phalcon/Db/AdapterInterface.php
new file mode 100644
index 000000000..efd9098ce
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/AdapterInterface.php
@@ -0,0 +1,196 @@
+
+ * use Phalcon\Db\Column as Column;
+ *
+ * //column definition
+ * $column = new Column("id", array(
+ * "type" => Column::TYPE_INTEGER,
+ * "size" => 10,
+ * "unsigned" => true,
+ * "notNull" => true,
+ * "autoIncrement" => true,
+ * "first" => true
+ * ));
+ *
+ * //add column to existing table
+ * $connection->addColumn("robots", null, $column);
+ *
+ *
+ */
+
+ class Column implements \Phalcon\Db\ColumnInterface {
+
+ const TYPE_INTEGER = 0;
+
+ const TYPE_DATE = 1;
+
+ const TYPE_VARCHAR = 2;
+
+ const TYPE_DECIMAL = 3;
+
+ const TYPE_DATETIME = 4;
+
+ const TYPE_CHAR = 5;
+
+ const TYPE_TEXT = 6;
+
+ const TYPE_FLOAT = 7;
+
+ const TYPE_BOOLEAN = 8;
+
+ const BIND_PARAM_NULL = 0;
+
+ const BIND_PARAM_INT = 1;
+
+ const BIND_PARAM_STR = 2;
+
+ const BIND_PARAM_BOOL = 5;
+
+ const BIND_PARAM_DECIMAL = 32;
+
+ const BIND_SKIP = 1024;
+
+ protected $_name;
+
+ protected $_schemaName;
+
+ protected $_type;
+
+ protected $_typeReference;
+
+ protected $_typeValues;
+
+ protected $_isNumeric;
+
+ protected $_size;
+
+ protected $_scale;
+
+ protected $_default;
+
+ protected $_unsigned;
+
+ protected $_notNull;
+
+ protected $_primary;
+
+ protected $_autoIncrement;
+
+ protected $_first;
+
+ protected $_after;
+
+ protected $_bindType;
+
+ /**
+ * Column's name
+ *
+ * @var string
+ */
+ public function getName(){ }
+
+
+ /**
+ * Schema which table related is
+ *
+ * @var string
+ */
+ public function getSchemaName(){ }
+
+
+ /**
+ * Column data type
+ *
+ * @var int|string
+ */
+ public function getType(){ }
+
+
+ /**
+ * Column data type reference
+ *
+ * @var int
+ */
+ public function getTypeReference(){ }
+
+
+ /**
+ * Column data type values
+ *
+ * @var array|string
+ */
+ public function getTypeValues(){ }
+
+
+ /**
+ * Integer column size
+ *
+ * @var int
+ */
+ public function getSize(){ }
+
+
+ /**
+ * Integer column number scale
+ *
+ * @var int
+ */
+ public function getScale(){ }
+
+
+ /**
+ * Default column value
+ */
+ public function getDefault(){ }
+
+
+ /**
+ * \Phalcon\Db\Column constructor
+ */
+ public function __construct($name, $definition){ }
+
+
+ /**
+ * Returns true if number column is unsigned
+ */
+ public function isUnsigned(){ }
+
+
+ /**
+ * Not null
+ */
+ public function isNotNull(){ }
+
+
+ /**
+ * Column is part of the primary key?
+ */
+ public function isPrimary(){ }
+
+
+ /**
+ * Auto-Increment
+ */
+ public function isAutoIncrement(){ }
+
+
+ /**
+ * Check whether column have an numeric type
+ */
+ public function isNumeric(){ }
+
+
+ /**
+ * Check whether column have first position in table
+ */
+ public function isFirst(){ }
+
+
+ /**
+ * Check whether field absolute to position in table
+ *
+ * @return string
+ */
+ public function getAfterPosition(){ }
+
+
+ /**
+ * Returns the type of bind handling
+ */
+ public function getBindType(){ }
+
+
+ /**
+ * Restores the internal state of a \Phalcon\Db\Column object
+ */
+ public static function __set_state($data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/ColumnInterface.php b/ide/2.0.2/Phalcon/Db/ColumnInterface.php
new file mode 100644
index 000000000..86c0dfce6
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/ColumnInterface.php
@@ -0,0 +1,61 @@
+
+ * $sql = $dialect->limit('SELECT * FROM robots', 10);
+ * echo $sql; // SELECT * FROM robots LIMIT 10
+ *
+ * $sql = $dialect->limit('SELECT * FROM robots', [10, 50]);
+ * echo $sql; // SELECT * FROM robots LIMIT 10 OFFSET 50
+ *
+ */
+ public function limit($sqlQuery, $number){ }
+
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ *
+ * $sql = $dialect->forUpdate('SELECT * FROM robots');
+ * echo $sql; // SELECT * FROM robots FOR UPDATE
+ *
+ */
+ public function forUpdate($sqlQuery){ }
+
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ *
+ * $sql = $dialect->sharedLock('SELECT * FROM robots');
+ * echo $sql; // SELECT * FROM robots LOCK IN SHARE MODE
+ *
+ */
+ public function sharedLock($sqlQuery){ }
+
+
+ /**
+ * Gets a list of columns with escaped identifiers
+ *
+ *
+ * echo $dialect->getColumnList(array('column1', 'column'));
+ *
+ */
+ final public function getColumnList($columnList){ }
+
+
+ /**
+ * Resolve Column expressions
+ */
+ final public function getSqlColumn($column){ }
+
+
+ /**
+ * Transforms an intermediate representation for a expression into a database system valid expression
+ */
+ public function getSqlExpression($expression, $escapeChar=null){ }
+
+
+ /**
+ * Transform an intermediate representation of a schema/table into a database system valid expression
+ */
+ final public function getSqlTable($table, $escapeChar=null){ }
+
+
+ /**
+ * Builds a SELECT statement
+ */
+ public function select($definition){ }
+
+
+ /**
+ * Checks whether the platform supports savepoints
+ */
+ public function supportsSavepoints(){ }
+
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ */
+ public function supportsReleaseSavepoints(){ }
+
+
+ /**
+ * Generate SQL to create a new savepoint
+ */
+ public function createSavepoint($name){ }
+
+
+ /**
+ * Generate SQL to release a savepoint
+ */
+ public function releaseSavepoint($name){ }
+
+
+ /**
+ * Generate SQL to rollback a savepoint
+ */
+ public function rollbackSavepoint($name){ }
+
+
+ /**
+ * Resolve Column expressions
+ */
+ final protected function getSqlExpressionScalar($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve object expressions
+ */
+ final protected function getSqlExpressionObject($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve qualified expressions
+ */
+ final protected function getSqlExpressionQualified($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve binary operations expressions
+ */
+ final protected function getSqlExpressionBinaryOperations($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve unary operations expressions
+ */
+ final protected function getSqlExpressionUnaryOperations($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve function calls
+ */
+ final protected function getSqlExpressionFunctionCall($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve Lists
+ */
+ final protected function getSqlExpressionList($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve *
+ */
+ final protected function getSqlExpressionAll($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve CAST of values
+ */
+ final protected function getSqlExpressionCastValue($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve CONVERT of values encodings
+ */
+ final protected function getSqlExpressionConvertValue($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve a FROM clause
+ */
+ final protected function getSqlExpressionFrom($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve a JOINs clause
+ */
+ final protected function getSqlExpressionJoins($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve a WHERE clause
+ */
+ final protected function getSqlExpressionWhere($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve a GROUP BY clause
+ */
+ final protected function getSqlExpressionGroupBy($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve a HAVING clause
+ */
+ final protected function getSqlExpressionHaving($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve a ORDER BY clause
+ */
+ final protected function getSqlExpressionOrderBy($expression, $escapeChar=null){ }
+
+
+ /**
+ * Resolve a LIMIT clause
+ */
+ final protected function getSqlExpressionLimit($expression, $escapeChar=null){ }
+
+
+ /**
+ * Prepares column for this RDBMS
+ */
+ protected function prepareColumnAlias($qualified, $alias=null){ }
+
+
+ /**
+ * Prepares table for this RDBMS
+ */
+ protected function prepareTable($table, $schema=null, $alias=null, $escapeChar=null){ }
+
+
+ /**
+ * Prepares qualified for this RDBMS
+ */
+ protected function prepareQualified($column, $domain=null, $escapeChar=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Dialect/MySQL.php b/ide/2.0.2/Phalcon/Db/Dialect/MySQL.php
new file mode 100644
index 000000000..224e9a558
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Dialect/MySQL.php
@@ -0,0 +1,166 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ */
+ public function tableExists($tableName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ */
+ public function viewExists($viewName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL describing a table
+ *
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ */
+ public function describeColumns($table, $schema=null){ }
+
+
+ /**
+ * List all tables in database
+ *
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ */
+ public function listTables($schemaName=null){ }
+
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ */
+ public function listViews($schemaName=null){ }
+
+
+ /**
+ * Generates SQL to query indexes on a table
+ */
+ public function describeIndexes($table, $schema=null){ }
+
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ */
+ public function describeReferences($table, $schema=null){ }
+
+
+ /**
+ * Generates the SQL to describe the table creation options
+ */
+ public function tableOptions($table, $schema=null){ }
+
+
+ /**
+ * Generates SQL to add the table creation options
+ */
+ protected function _getTableOptions($definition){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Dialect/Oracle.php b/ide/2.0.2/Phalcon/Db/Dialect/Oracle.php
new file mode 100644
index 000000000..fca37a5ef
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Dialect/Oracle.php
@@ -0,0 +1,179 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ */
+ public function tableExists($tableName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL describing a table
+ *
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ */
+ public function describeColumns($table, $schema=null){ }
+
+
+ /**
+ * List all tables in database
+ *
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ */
+ public function listTables($schemaName=null){ }
+
+
+ /**
+ * Generates SQL to query indexes on a table
+ */
+ public function describeIndexes($table, $schema=null){ }
+
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ */
+ public function describeReferences($table, $schema=null){ }
+
+
+ /**
+ * Generates the SQL to describe the table creation options
+ */
+ public function tableOptions($table, $schema=null){ }
+
+
+ /**
+ * Checks whether the platform supports savepoints
+ */
+ public function supportsSavepoints(){ }
+
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ */
+ public function supportsReleaseSavepoints(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Dialect/Postgresql.php b/ide/2.0.2/Phalcon/Db/Dialect/Postgresql.php
new file mode 100644
index 000000000..51cdf1a16
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Dialect/Postgresql.php
@@ -0,0 +1,166 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ */
+ public function tableExists($tableName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ */
+ public function viewExists($viewName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL describing a table
+ *
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ */
+ public function describeColumns($table, $schema=null){ }
+
+
+ /**
+ * List all tables in database
+ *
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ */
+ public function listTables($schemaName=null){ }
+
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string schemaName
+ * @return string
+ */
+ public function listViews($schemaName=null){ }
+
+
+ /**
+ * Generates SQL to query indexes on a table
+ */
+ public function describeIndexes($table, $schema=null){ }
+
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ */
+ public function describeReferences($table, $schema=null){ }
+
+
+ /**
+ * Generates the SQL to describe the table creation options
+ */
+ public function tableOptions($table, $schema=null){ }
+
+
+ protected function _getTableOptions($definition){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Dialect/Sqlite.php b/ide/2.0.2/Phalcon/Db/Dialect/Sqlite.php
new file mode 100644
index 000000000..bbe471082
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Dialect/Sqlite.php
@@ -0,0 +1,166 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ */
+ public function tableExists($tableName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ */
+ public function viewExists($viewName, $schemaName=null){ }
+
+
+ /**
+ * Generates SQL describing a table
+ *
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ */
+ public function describeColumns($table, $schema=null){ }
+
+
+ /**
+ * List all tables in database
+ *
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ */
+ public function listTables($schemaName=null){ }
+
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ */
+ public function listViews($schemaName=null){ }
+
+
+ /**
+ * Generates SQL to query indexes on a table
+ */
+ public function describeIndexes($table, $schema=null){ }
+
+
+ /**
+ * Generates SQL to query indexes detail on a table
+ */
+ public function describeIndex($index){ }
+
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ */
+ public function describeReferences($table, $schema=null){ }
+
+
+ /**
+ * Generates the SQL to describe the table creation options
+ */
+ public function tableOptions($table, $schema=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/DialectInterface.php b/ide/2.0.2/Phalcon/Db/DialectInterface.php
new file mode 100644
index 000000000..014ea433a
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/DialectInterface.php
@@ -0,0 +1,100 @@
+
+ *
+ * $profiler = new \Phalcon\Db\Profiler();
+ *
+ * //Set the connection profiler
+ * $connection->setProfiler($profiler);
+ *
+ * $sql = "SELECT buyer_name, quantity, product_name
+ * FROM buyers LEFT JOIN products ON
+ * buyers.pid=products.id";
+ *
+ * //Execute a SQL statement
+ * $connection->query($sql);
+ *
+ * //Get the last profile in the profiler
+ * $profile = $profiler->getLastProfile();
+ *
+ * echo "SQL Statement: ", $profile->getSQLStatement(), "\n";
+ * echo "Start Time: ", $profile->getInitialTime(), "\n";
+ * echo "Final Time: ", $profile->getFinalTime(), "\n";
+ * echo "Total Elapsed Time: ", $profile->getTotalElapsedSeconds(), "\n";
+ *
+ *
+ *
+ */
+
+ class Profiler {
+
+ protected $_allProfiles;
+
+ protected $_activeProfile;
+
+ protected $_totalSeconds;
+
+ /**
+ * Starts the profile of a SQL sentence
+ *
+ * @param string sqlStatement
+ * @return \Phalcon\Db\Profiler
+ */
+ public function startProfile($sqlStatement, $sqlVariables=null, $sqlBindTypes=null){ }
+
+
+ /**
+ * Stops the active profile
+ */
+ public function stopProfile(){ }
+
+
+ /**
+ * Returns the total number of SQL statements processed
+ */
+ public function getNumberTotalStatements(){ }
+
+
+ /**
+ * Returns the total time in seconds spent by the profiles
+ */
+ public function getTotalElapsedSeconds(){ }
+
+
+ /**
+ * Returns all the processed profiles
+ */
+ public function getProfiles(){ }
+
+
+ /**
+ * Resets the profiler, cleaning up all the profiles
+ */
+ public function reset(){ }
+
+
+ /**
+ * Returns the last profile executed in the profiler
+ */
+ public function getLastProfile(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Profiler/Item.php b/ide/2.0.2/Phalcon/Db/Profiler/Item.php
new file mode 100644
index 000000000..8edda98f3
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Profiler/Item.php
@@ -0,0 +1,110 @@
+
+ * $subscriber = new Subscribers();
+ * $subscriber->email = 'andres@phalconphp.com';
+ * $subscriber->createdAt = new \Phalcon\Db\RawValue('now()');
+ * $subscriber->save();
+ *
+ */
+
+ class RawValue {
+
+ protected $_value;
+
+ /**
+ * Raw value without quoting or formating
+ *
+ * @var string
+ */
+ public function getValue(){ }
+
+
+ /**
+ * Raw value without quoting or formating
+ *
+ * @var string
+ */
+ public function __toString(){ }
+
+
+ /**
+ * \Phalcon\Db\RawValue constructor
+ */
+ public function __construct($value){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/Reference.php b/ide/2.0.2/Phalcon/Db/Reference.php
new file mode 100644
index 000000000..55010cae8
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/Reference.php
@@ -0,0 +1,104 @@
+
+ * $reference = new \Phalcon\Db\Reference("field_fk", array(
+ * 'referencedSchema' => "invoicing",
+ * 'referencedTable' => "products",
+ * 'columns' => array("product_type", "product_code"),
+ * 'referencedColumns' => array("type", "code")
+ * ));
+ *
+ */
+
+ class Reference implements \Phalcon\Db\ReferenceInterface {
+
+ protected $_name;
+
+ protected $_schemaName;
+
+ protected $_referencedSchema;
+
+ protected $_referencedTable;
+
+ protected $_columns;
+
+ protected $_referencedColumns;
+
+ protected $_onDelete;
+
+ protected $_onUpdate;
+
+ /**
+ * Constraint name
+ *
+ * @var string
+ */
+ public function getName(){ }
+
+
+ public function getSchemaName(){ }
+
+
+ public function getReferencedSchema(){ }
+
+
+ /**
+ * Referenced Table
+ *
+ * @var string
+ */
+ public function getReferencedTable(){ }
+
+
+ /**
+ * Local reference columns
+ *
+ * @var array
+ */
+ public function getColumns(){ }
+
+
+ /**
+ * Referenced Columns
+ *
+ * @var array
+ */
+ public function getReferencedColumns(){ }
+
+
+ /**
+ * ON DELETE
+ *
+ * @var array
+ */
+ public function getOnDelete(){ }
+
+
+ /**
+ * ON UPDATE
+ *
+ * @var array
+ */
+ public function getOnUpdate(){ }
+
+
+ /**
+ * \Phalcon\Db\Reference constructor
+ */
+ public function __construct($name, $definition){ }
+
+
+ /**
+ * Restore a \Phalcon\Db\Reference object from export
+ */
+ public static function __set_state($data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/ReferenceInterface.php b/ide/2.0.2/Phalcon/Db/ReferenceInterface.php
new file mode 100644
index 000000000..155e157ab
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/ReferenceInterface.php
@@ -0,0 +1,37 @@
+
+ * $result = $connection->query("SELECT * FROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ */
+
+ class Pdo implements \Phalcon\Db\ResultInterface {
+
+ protected $_connection;
+
+ protected $_result;
+
+ protected $_fetchMode;
+
+ protected $_pdoStatement;
+
+ protected $_sqlStatement;
+
+ protected $_bindParams;
+
+ protected $_bindTypes;
+
+ protected $_rowCount;
+
+ /**
+ * \Phalcon\Db\Result\Pdo constructor
+ *
+ * @param \Phalcon\Db\AdapterInterface connection
+ * @param \PDOStatement result
+ * @param string sqlStatement
+ * @param array bindParams
+ * @param array bindTypes
+ */
+ public function __construct(\Phalcon\Db\AdapterInterface $connection, \PDOStatement $result, $sqlStatement=null, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Allows to execute the statement again. Some database systems don't support scrollable cursors,
+ * So, as cursors are forward only, we need to execute the cursor again to fetch rows from the begining
+ */
+ public function execute(){ }
+
+
+ /**
+ * Fetches an array/object of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using \Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ *
+ * $result = $connection->query("SELECT * FROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ * while ($robot = $result->fetch()) {
+ * echo robot->name;
+ * }
+ *
+ *
+ * @return mixed
+ */
+ public function fetch(){ }
+
+
+ /**
+ * Returns an array of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using \Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ *
+ * $result = $connection->query("SELECT * FROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ *
+ * @return mixed
+ */
+ public function fetchArray(){ }
+
+
+ /**
+ * Returns an array of arrays containing all the records in the result
+ * This method is affected by the active fetch flag set using \Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ *
+ * $result = $connection->query("SELECT * FROM robots ORDER BY name");
+ * $robots = $result->fetchAll();
+ *
+ *
+ * @return array
+ */
+ public function fetchAll(){ }
+
+
+ /**
+ * Gets number of rows returned by a resulset
+ *
+ *
+ * $result = $connection->query("SELECT * FROM robots ORDER BY name");
+ * echo 'There are ', $result->numRows(), ' rows in the resulset';
+ *
+ */
+ public function numRows(){ }
+
+
+ /**
+ * Moves internal resulset cursor to another position letting us to fetch a certain row
+ *
+ *
+ * $result = $connection->query("SELECT * FROM robots ORDER BY name");
+ * $result->dataSeek(2); // Move to third row on result
+ * $row = $result->fetch(); // Fetch third row
+ *
+ */
+ public function dataSeek($number){ }
+
+
+ /**
+ * Changes the fetching mode affecting \Phalcon\Db\Result\Pdo::fetch()
+ *
+ *
+ * //Return array with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ *
+ * //Return associative array without integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_ASSOC);
+ *
+ * //Return associative array together with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_BOTH);
+ *
+ * //Return an object
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ *
+ */
+ public function setFetchMode($fetchMode){ }
+
+
+ /**
+ * Gets the internal PDO result object
+ */
+ public function getInternalResult(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Db/ResultInterface.php b/ide/2.0.2/Phalcon/Db/ResultInterface.php
new file mode 100644
index 000000000..407e9452b
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Db/ResultInterface.php
@@ -0,0 +1,34 @@
+
+ * $foo = 123;
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ */
+
+ class Dump {
+
+ protected $_detailed;
+
+ protected $_methods;
+
+ protected $_styles;
+
+ public function getDetailed(){ }
+
+
+ public function setDetailed($detailed){ }
+
+
+ /**
+ * \Phalcon\Debug\Dump constructor
+ *
+ * @param boolean detailed debug object's private and protected properties
+ */
+ public function __construct($styles=null, $detailed=null){ }
+
+
+ /**
+ * Alias of variables() method
+ *
+ * @param mixed variable
+ * @param ...
+ */
+ public function all(){ }
+
+
+ /**
+ * Get style for type
+ */
+ protected function getStyle($type){ }
+
+
+ /**
+ * Set styles for vars type
+ */
+ public function setStyles($styles=null){ }
+
+
+ /**
+ * Alias of variable() method
+ */
+ public function one($variable, $name=null){ }
+
+
+ /**
+ * Prepare an HTML string of information about a single variable.
+ */
+ protected function output($variable, $name=null, $tab=null){ }
+
+
+ /**
+ * Returns an HTML string of information about a single variable.
+ *
+ *
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ */
+ public function variable($variable, $name=null){ }
+
+
+ /**
+ * Returns an HTML string of debugging information about any number of
+ * variables, each wrapped in a "pre" tag.
+ *
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ *
+ * @param mixed variable
+ * @param ...
+ */
+ public function variables(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Debug/Exception.php b/ide/2.0.2/Phalcon/Debug/Exception.php
new file mode 100644
index 000000000..36c260f38
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Debug/Exception.php
@@ -0,0 +1,7 @@
+
+ * $di = new \Phalcon\Di();
+ *
+ * //Using a string definition
+ * $di->set("request", "Phalcon\Http\Request", true);
+ *
+ * //Using an anonymous function
+ * $di->set("request", function(){
+ * return new \Phalcon\Http\Request();
+ * }, true);
+ *
+ * $request = $di->getRequest();
+ *
+ *
+ */
+
+ class Di implements \Phalcon\DiInterface, \ArrayAccess {
+
+ protected $_services;
+
+ protected $_sharedInstances;
+
+ protected $_freshInstance;
+
+ protected $_eventsManager;
+
+ protected static $_default;
+
+ /**
+ * \Phalcon\Di constructor
+ */
+ public function __construct(){ }
+
+
+ /**
+ * Sets the internal event manager
+ */
+ public function setInternalEventsManager(\Phalcon\Events\ManagerInterface $eventsManager){ }
+
+
+ /**
+ * Returns the internal event manager
+ */
+ public function getInternalEventsManager(){ }
+
+
+ /**
+ * Registers a service in the services container
+ */
+ public function set($name, $definition, $shared=null){ }
+
+
+ /**
+ * Registers an "always shared" service in the services container
+ */
+ public function setShared($name, $definition){ }
+
+
+ /**
+ * Removes a service in the services container
+ */
+ public function remove($name){ }
+
+
+ /**
+ * Attempts to register a service in the services container
+ * Only is successful if a service hasn"t been registered previously
+ * with the same name
+ */
+ public function attempt($name, $definition, $shared=null){ }
+
+
+ /**
+ * Sets a service using a raw \Phalcon\Di\Service definition
+ */
+ public function setRaw($name, \Phalcon\Di\ServiceInterface $rawDefinition){ }
+
+
+ /**
+ * Returns a service definition without resolving
+ */
+ public function getRaw($name){ }
+
+
+ /**
+ * Returns a \Phalcon\Di\Service instance
+ */
+ public function getService($name){ }
+
+
+ /**
+ * Resolves the service based on its configuration
+ */
+ public function get($name, $parameters=null){ }
+
+
+ /**
+ * Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
+ *
+ * @param string name
+ * @param array parameters
+ * @return mixed
+ */
+ public function getShared($name, $parameters=null){ }
+
+
+ /**
+ * Check whether the DI contains a service by a name
+ */
+ public function has($name){ }
+
+
+ /**
+ * Check whether the last service obtained via getShared produced a fresh instance or an existing one
+ */
+ public function wasFreshInstance(){ }
+
+
+ /**
+ * Return the services registered in the DI
+ */
+ public function getServices(){ }
+
+
+ /**
+ * Check if a service is registered using the array syntax
+ */
+ public function offsetExists($name){ }
+
+
+ /**
+ * Allows to register a shared service using the array syntax
+ *
+ *
+ * $di["request"] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string name
+ * @param mixed definition
+ * @return boolean
+ */
+ public function offsetSet($name, $definition){ }
+
+
+ /**
+ * Allows to obtain a shared service using the array syntax
+ *
+ *
+ * var_dump($di["request"]);
+ *
+ *
+ * @param string name
+ * @return mixed
+ */
+ public function offsetGet($name){ }
+
+
+ /**
+ * Removes a service from the services container using the array syntax
+ */
+ public function offsetUnset($name){ }
+
+
+ /**
+ * Magic method to get or set services using setters/getters
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ */
+ public function __call($method, $arguments=null){ }
+
+
+ /**
+ * Set a default dependency injection container to be obtained into static methods
+ */
+ public static function setDefault(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Return the lastest DI created
+ */
+ public static function getDefault(){ }
+
+
+ /**
+ * Resets the internal default DI
+ */
+ public static function reset(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Di/Exception.php b/ide/2.0.2/Phalcon/Di/Exception.php
new file mode 100644
index 000000000..5f574390d
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Di/Exception.php
@@ -0,0 +1,7 @@
+
+ * $service = new \Phalcon\Di\Service('request', 'Phalcon\Http\Request');
+ * $request = service->resolve();
+ *
+ *
+ */
+
+ class Service implements \Phalcon\Di\ServiceInterface {
+
+ protected $_name;
+
+ protected $_definition;
+
+ protected $_shared;
+
+ protected $_resolved;
+
+ protected $_sharedInstance;
+
+ /**
+ * \Phalcon\Di\Service
+ *
+ * @param string name
+ * @param mixed definition
+ * @param boolean shared
+ */
+ final public function __construct($name, $definition, $shared=null){ }
+
+
+ /**
+ * Returns the service's name
+ */
+ public function getName(){ }
+
+
+ /**
+ * Sets if the service is shared or not
+ */
+ public function setShared($shared){ }
+
+
+ /**
+ * Check whether the service is shared or not
+ */
+ public function isShared(){ }
+
+
+ /**
+ * Sets/Resets the shared instance related to the service
+ *
+ * @param mixed sharedInstance
+ */
+ public function setSharedInstance($sharedInstance){ }
+
+
+ /**
+ * Set the service definition
+ *
+ * @param mixed definition
+ */
+ public function setDefinition($definition){ }
+
+
+ /**
+ * Returns the service definition
+ *
+ * @return mixed
+ */
+ public function getDefinition(){ }
+
+
+ /**
+ * Resolves the service
+ *
+ * @param array parameters
+ * @param \Phalcon\DiInterface dependencyInjector
+ * @return mixed
+ */
+ public function resolve($parameters=null, \Phalcon\DiInterface $dependencyInjector=null){ }
+
+
+ /**
+ * Changes a parameter in the definition without resolve the service
+ */
+ public function setParameter($position, $parameter){ }
+
+
+ /**
+ * Returns a parameter in a specific position
+ *
+ * @param int position
+ * @return array
+ */
+ public function getParameter($position){ }
+
+
+ /**
+ * Returns true if the service was resolved
+ */
+ public function isResolved(){ }
+
+
+ /**
+ * Restore the internal state of a service
+ */
+ public static function __set_state($attributes){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Di/Service/Builder.php b/ide/2.0.2/Phalcon/Di/Service/Builder.php
new file mode 100644
index 000000000..d99437b1f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Di/Service/Builder.php
@@ -0,0 +1,41 @@
+
+ * $this->dispatcher->forward(array("controller" => "posts", "action" => "index"));
+ *
+ *
+ * @param array forward
+ */
+ public function forward($forward){ }
+
+
+ /**
+ * Check if the current executed action was forwarded by another one
+ */
+ public function wasForwarded(){ }
+
+
+ /**
+ * Possible class name that will be located to dispatch the request
+ */
+ public function getHandlerClass(){ }
+
+
+ /**
+ * Set empty properties to their defaults (where defaults are available)
+ */
+ protected function _resolveEmptyProperties(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/DispatcherInterface.php b/ide/2.0.2/Phalcon/DispatcherInterface.php
new file mode 100644
index 000000000..13e77fbe5
--- /dev/null
+++ b/ide/2.0.2/Phalcon/DispatcherInterface.php
@@ -0,0 +1,52 @@
+
+ * $escaper = new \Phalcon\Escaper();
+ * $escaped = $escaper->escapeCss("font-family:
+ * $escaper->setEncoding('utf-8');
+ *
+ */
+ public function setEncoding($encoding){ }
+
+
+ /**
+ * Returns the internal encoding used by the escaper
+ */
+ public function getEncoding(){ }
+
+
+ /**
+ * Sets the HTML quoting type for htmlspecialchars
+ *
+ *
+ * $escaper->setHtmlQuoteType(ENT_XHTML);
+ *
+ */
+ public function setHtmlQuoteType($quoteType){ }
+
+
+ /**
+ * Detect the character encoding of a string to be handled by an encoder
+ * Special-handling for chr(172) and chr(128) to chr(159) which fail to be detected by mb_detect_encoding()
+ */
+ final public function detectEncoding($str){ }
+
+
+ /**
+ * Utility to normalize a string's encoding to UTF-32.
+ */
+ final public function normalizeEncoding($str){ }
+
+
+ /**
+ * Escapes a HTML string. Internally uses htmlspecialchars
+ */
+ public function escapeHtml($text){ }
+
+
+ /**
+ * Escapes a HTML attribute string
+ */
+ public function escapeHtmlAttr($attribute){ }
+
+
+ /**
+ * Escape CSS strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ */
+ public function escapeCss($css){ }
+
+
+ /**
+ * Escape javascript strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ */
+ public function escapeJs($js){ }
+
+
+ /**
+ * Escapes a URL. Internally uses rawurlencode
+ */
+ public function escapeUrl($url){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Escaper/Exception.php b/ide/2.0.2/Phalcon/Escaper/Exception.php
new file mode 100644
index 000000000..bbe51c05f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Escaper/Exception.php
@@ -0,0 +1,7 @@
+
+ * $eventsManager->fire('db', $connection);
+ *
+ *
+ * @param string eventType
+ * @param object source
+ * @param mixed data
+ * @param boolean cancelable
+ * @return mixed
+ */
+ public function fire($eventType, $source, $data=null, $cancelable=null){ }
+
+
+ /**
+ * Check whether certain type of event has listeners
+ */
+ public function hasListeners($type){ }
+
+
+ /**
+ * Returns all the attached listeners of a certain type
+ *
+ * @param string type
+ * @return array
+ */
+ public function getListeners($type){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Events/ManagerInterface.php b/ide/2.0.2/Phalcon/Events/ManagerInterface.php
new file mode 100644
index 000000000..480ad7fb1
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Events/ManagerInterface.php
@@ -0,0 +1,22 @@
+
+ * $filter = new \Phalcon\Filter();
+ * $filter->sanitize("some(one)@exa\\mple.com", "email"); // returns "someone@example.com"
+ * $filter->sanitize("hello<<", "string"); // returns "hello"
+ * $filter->sanitize("!100a019", "int"); // returns "100019"
+ * $filter->sanitize("!100a019.01a", "float"); // returns "100019.01"
+ *
+ */
+
+ class Filter implements \Phalcon\FilterInterface {
+
+ const FILTER_EMAIL = email;
+
+ const FILTER_ABSINT = absint;
+
+ const FILTER_INT = int;
+
+ const FILTER_INT_CAST = int!;
+
+ const FILTER_STRING = string;
+
+ const FILTER_FLOAT = float;
+
+ const FILTER_FLOAT_CAST = float!;
+
+ const FILTER_ALPHANUM = alphanum;
+
+ const FILTER_TRIM = trim;
+
+ const FILTER_STRIPTAGS = striptags;
+
+ const FILTER_LOWER = lower;
+
+ const FILTER_UPPER = upper;
+
+ protected $_filters;
+
+ /**
+ * Adds a user-defined filter
+ */
+ public function add($name, $handler){ }
+
+
+ /**
+ * Sanitizes a value with a specified single or set of filters
+ */
+ public function sanitize($value, $filters, $noRecursive=null){ }
+
+
+ /**
+ * Internal sanitize wrapper to filter_var
+ */
+ protected function _sanitize($value, $filter){ }
+
+
+ /**
+ * Return the user-defined filters in the instance
+ */
+ public function getFilters(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Filter/Exception.php b/ide/2.0.2/Phalcon/Filter/Exception.php
new file mode 100644
index 000000000..80970fa01
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Filter/Exception.php
@@ -0,0 +1,7 @@
+
+ * $flash->success("The record was successfully deleted");
+ * $flash->error("Cannot open the file");
+ *
+ */
+
+ abstract class Flash {
+
+ protected $_cssClasses;
+
+ protected $_implicitFlush;
+
+ protected $_automaticHtml;
+
+ /**
+ * \Phalcon\Flash constructor
+ */
+ public function __construct($cssClasses=null){ }
+
+
+ /**
+ * Set whether the output must be implicitly flushed to the output or returned as string
+ */
+ public function setImplicitFlush($implicitFlush){ }
+
+
+ /**
+ * Set if the output must be implicitly formatted with HTML
+ */
+ public function setAutomaticHtml($automaticHtml){ }
+
+
+ /**
+ * Set an array with CSS classes to format the messages
+ */
+ public function setCssClasses($cssClasses){ }
+
+
+ /**
+ * Shows a HTML error message
+ *
+ *
+ * $flash->error('This is an error');
+ *
+ */
+ public function error($message){ }
+
+
+ /**
+ * Shows a HTML notice/information message
+ *
+ *
+ * $flash->notice('This is an information');
+ *
+ */
+ public function notice($message){ }
+
+
+ /**
+ * Shows a HTML success message
+ *
+ *
+ * $flash->success('The process was finished successfully');
+ *
+ */
+ public function success($message){ }
+
+
+ /**
+ * Shows a HTML warning message
+ *
+ *
+ * $flash->warning('Hey, this is important');
+ *
+ */
+ public function warning($message){ }
+
+
+ /**
+ * Outputs a message formatting it with HTML
+ *
+ *
+ * $flash->outputMessage('error', message);
+ *
+ *
+ * @param string|array message
+ */
+ public function outputMessage($type, $message){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Flash/Direct.php b/ide/2.0.2/Phalcon/Flash/Direct.php
new file mode 100644
index 000000000..b269e4eb8
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Flash/Direct.php
@@ -0,0 +1,21 @@
+Encapsulates request information for easy and secure access from application controllers.
+ *
+ * The request object is a simple value object that is passed between the dispatcher and controller classes. + * It packages the HTTP request environment.
+ * + *
+ * $request = new \Phalcon\Http\Request();
+ * if ($request->isPost() == true) {
+ * if ($request->isAjax() == true) {
+ * echo 'Request was made using POST and AJAX';
+ * }
+ * }
+ *
+ *
+ */
+
+ class Request implements \Phalcon\Http\RequestInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_rawBody;
+
+ protected $_filter;
+
+ protected $_putCache;
+
+ /**
+ * Sets the dependency injector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the internal dependency injector
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Gets a variable from the $_REQUEST superglobal applying filters if needed.
+ * If no parameters are given the $_REQUEST superglobal is returned
+ *
+ *
+ * //Returns value from $_REQUEST["user_email"] without sanitizing
+ * $userEmail = $request->get("user_email");
+ *
+ * //Returns value from $_REQUEST["user_email"] with sanitizing
+ * $userEmail = $request->get("user_email", "email");
+ *
+ */
+ public function get($name=null, $filters=null, $defaultValue=null, $notAllowEmpty=null, $noRecursive=null){ }
+
+
+ /**
+ * Gets a variable from the $_POST superglobal applying filters if needed
+ * If no parameters are given the $_POST superglobal is returned
+ *
+ *
+ * //Returns value from $_POST["user_email"] without sanitizing
+ * $userEmail = $request->getPost("user_email");
+ *
+ * //Returns value from $_POST["user_email"] with sanitizing
+ * $userEmail = $request->getPost("user_email", "email");
+ *
+ */
+ public function getPost($name=null, $filters=null, $defaultValue=null, $notAllowEmpty=null, $noRecursive=null){ }
+
+
+ /**
+ * Gets a variable from put request
+ *
+ *
+ * //Returns value from $_PUT["user_email"] without sanitizing
+ * $userEmail = $request->getPut("user_email");
+ *
+ * //Returns value from $_PUT["user_email"] with sanitizing
+ * $userEmail = $request->getPut("user_email", "email");
+ *
+ */
+ public function getPut($name=null, $filters=null, $defaultValue=null, $notAllowEmpty=null, $noRecursive=null){ }
+
+
+ /**
+ * Gets variable from $_GET superglobal applying filters if needed
+ * If no parameters are given the $_GET superglobal is returned
+ *
+ *
+ * //Returns value from $_GET["id"] without sanitizing
+ * $id = $request->getQuery("id");
+ *
+ * //Returns value from $_GET["id"] with sanitizing
+ * $id = $request->getQuery("id", "int");
+ *
+ * //Returns value from $_GET["id"] with a default value
+ * $id = $request->getQuery("id", null, 150);
+ *
+ */
+ public function getQuery($name=null, $filters=null, $defaultValue=null, $notAllowEmpty=null, $noRecursive=null){ }
+
+
+ /**
+ * Helper to get data from superglobals, applying filters if needed.
+ * If no parameters are given the superglobal is returned.
+ */
+ final protected function getHelper($source, $name=null, $filters=null, $defaultValue=null, $notAllowEmpty=null, $noRecursive=null){ }
+
+
+ /**
+ * Gets variable from $_SERVER superglobal
+ */
+ public function getServer($name){ }
+
+
+ /**
+ * Checks whether $_REQUEST superglobal has certain index
+ */
+ public function has($name){ }
+
+
+ /**
+ * Checks whether $_POST superglobal has certain index
+ */
+ public function hasPost($name){ }
+
+
+ /**
+ * Checks whether the PUT data has certain index
+ */
+ public function hasPut($name){ }
+
+
+ /**
+ * Checks whether $_GET superglobal has certain index
+ */
+ public function hasQuery($name){ }
+
+
+ /**
+ * Checks whether $_SERVER superglobal has certain index
+ */
+ final public function hasServer($name){ }
+
+
+ /**
+ * Gets HTTP header from request data
+ */
+ final public function getHeader($header){ }
+
+
+ /**
+ * Gets HTTP schema (http/https)
+ */
+ public function getScheme(){ }
+
+
+ /**
+ * Checks whether request has been made using ajax
+ */
+ public function isAjax(){ }
+
+
+ /**
+ * Checks whether request has been made using SOAP
+ */
+ public function isSoapRequested(){ }
+
+
+ /**
+ * Checks whether request has been made using any secure layer
+ */
+ public function isSecureRequest(){ }
+
+
+ /**
+ * Gets HTTP raw request body
+ */
+ public function getRawBody(){ }
+
+
+ /**
+ * Gets decoded JSON HTTP raw request body
+ */
+ public function getJsonRawBody($associative=null){ }
+
+
+ /**
+ * Gets active server address IP
+ */
+ public function getServerAddress(){ }
+
+
+ /**
+ * Gets active server name
+ */
+ public function getServerName(){ }
+
+
+ /**
+ * Gets information about schema, host and port used by the request
+ */
+ public function getHttpHost(){ }
+
+
+ /**
+ * Gets HTTP URI which request has been made
+ */
+ final public function getURI(){ }
+
+
+ /**
+ * Gets most possible client IPv4 Address. This method search in _SERVER['REMOTE_ADDR'] and optionally in _SERVER['HTTP_X_FORWARDED_FOR']
+ */
+ public function getClientAddress($trustForwardedHeader=null){ }
+
+
+ /**
+ * Gets HTTP method which request has been made
+ */
+ final public function getMethod(){ }
+
+
+ /**
+ * Gets HTTP user agent used to made the request
+ */
+ public function getUserAgent(){ }
+
+
+ /**
+ * Check if HTTP method match any of the passed methods
+ */
+ public function isMethod($methods){ }
+
+
+ /**
+ * Checks whether HTTP method is POST. if _SERVER["REQUEST_METHOD"]==="POST"
+ */
+ public function isPost(){ }
+
+
+ /**
+ * Checks whether HTTP method is GET. if _SERVER["REQUEST_METHOD"]==="GET"
+ */
+ public function isGet(){ }
+
+
+ /**
+ * Checks whether HTTP method is PUT. if _SERVER["REQUEST_METHOD"]==="PUT"
+ */
+ public function isPut(){ }
+
+
+ /**
+ * Checks whether HTTP method is PATCH. if _SERVER["REQUEST_METHOD"]==="PATCH"
+ */
+ public function isPatch(){ }
+
+
+ /**
+ * Checks whether HTTP method is HEAD. if _SERVER["REQUEST_METHOD"]==="HEAD"
+ */
+ public function isHead(){ }
+
+
+ /**
+ * Checks whether HTTP method is DELETE. if _SERVER["REQUEST_METHOD"]==="DELETE"
+ */
+ public function isDelete(){ }
+
+
+ /**
+ * Checks whether HTTP method is OPTIONS. if _SERVER["REQUEST_METHOD"]==="OPTIONS"
+ */
+ public function isOptions(){ }
+
+
+ /**
+ * Checks whether request include attached files
+ */
+ public function hasFiles($onlySuccessful=null){ }
+
+
+ /**
+ * Recursively counts file in an array of files
+ */
+ final protected function hasFileHelper($data, $onlySuccessful){ }
+
+
+ /**
+ * Gets attached files as \Phalcon\Http\Request\File instances
+ */
+ public function getUploadedFiles($onlySuccessful=null){ }
+
+
+ /**
+ * Smooth out $_FILES to have plain array with all files uploaded
+ */
+ final protected function smoothFiles($names, $types, $tmp_names, $sizes, $errors, $prefix){ }
+
+
+ /**
+ * Returns the available headers in the request
+ */
+ public function getHeaders(){ }
+
+
+ /**
+ * Gets web page that refers active request. ie: http://www.google.com
+ */
+ public function getHTTPReferer(){ }
+
+
+ /**
+ * Process a request header and return an array of values with their qualities
+ */
+ final protected function _getQualityHeader($serverIndex, $name){ }
+
+
+ /**
+ * Process a request header and return the one with best quality
+ */
+ final protected function _getBestQuality($qualityParts, $name){ }
+
+
+ /**
+ * Gets content type which request has been made
+ */
+ public function getContentType(){ }
+
+
+ /**
+ * Gets an array with mime/types and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ */
+ public function getAcceptableContent(){ }
+
+
+ /**
+ * Gets best mime/type accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ */
+ public function getBestAccept(){ }
+
+
+ /**
+ * Gets a charsets array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ */
+ public function getClientCharsets(){ }
+
+
+ /**
+ * Gets best charset accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ */
+ public function getBestCharset(){ }
+
+
+ /**
+ * Gets languages array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ */
+ public function getLanguages(){ }
+
+
+ /**
+ * Gets best language accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ */
+ public function getBestLanguage(){ }
+
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_USER']
+ */
+ public function getBasicAuth(){ }
+
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_DIGEST']
+ */
+ public function getDigestAuth(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Http/Request/Exception.php b/ide/2.0.2/Phalcon/Http/Request/Exception.php
new file mode 100644
index 000000000..01b5f6c5b
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Http/Request/Exception.php
@@ -0,0 +1,7 @@
+
+ * class PostsController extends \Phalcon\Mvc\Controller
+ * {
+ *
+ * public function uploadAction()
+ * {
+ * //Check if the user has uploaded files
+ * if ($this->request->hasFiles() == true) {
+ * //Print the real file names and their sizes
+ * foreach ($this->request->getUploadedFiles() as $file){
+ * echo $file->getName(), " ", $file->getSize(), "\n";
+ * }
+ * }
+ * }
+ *
+ * }
+ *
+ */
+
+ class File implements \Phalcon\Http\Request\FileInterface {
+
+ protected $_name;
+
+ protected $_tmp;
+
+ protected $_size;
+
+ protected $_type;
+
+ protected $_realType;
+
+ protected $_error;
+
+ protected $_key;
+
+ protected $_extension;
+
+ public function getError(){ }
+
+
+ public function getKey(){ }
+
+
+ public function getExtension(){ }
+
+
+ /**
+ * \Phalcon\Http\Request\File constructor
+ */
+ public function __construct($file, $key=null){ }
+
+
+ /**
+ * Returns the file size of the uploaded file
+ */
+ public function getSize(){ }
+
+
+ /**
+ * Returns the real name of the uploaded file
+ */
+ public function getName(){ }
+
+
+ /**
+ * Returns the temporal name of the uploaded file
+ */
+ public function getTempName(){ }
+
+
+ /**
+ * Returns the mime type reported by the browser
+ * This mime type is not completely secure, use getRealType() instead
+ */
+ public function getType(){ }
+
+
+ /**
+ * Gets the real mime type of the upload file using finfo
+ */
+ public function getRealType(){ }
+
+
+ /**
+ * Checks whether the file has been uploaded via Post.
+ */
+ public function isUploadedFile(){ }
+
+
+ /**
+ * Moves the temporary file to a destination within the application
+ */
+ public function moveTo($destination){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Http/Request/FileInterface.php b/ide/2.0.2/Phalcon/Http/Request/FileInterface.php
new file mode 100644
index 000000000..65b68afad
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Http/Request/FileInterface.php
@@ -0,0 +1,28 @@
+
+ * $response = new \Phalcon\Http\Response();
+ * $response->setStatusCode(200, "OK");
+ * $response->setContent("Hello");
+ * $response->send();
+ *
+ */
+
+ class Response implements \Phalcon\Http\ResponseInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_sent;
+
+ protected $_content;
+
+ protected $_headers;
+
+ protected $_cookies;
+
+ protected $_file;
+
+ protected $_dependencyInjector;
+
+ protected $_statusCodes;
+
+ /**
+ * \Phalcon\Http\Response constructor
+ *
+ * @param string content
+ * @param int code
+ * @param string status
+ */
+ public function __construct($content=null, $code=null, $status=null){ }
+
+
+ /**
+ * Sets the dependency injector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the internal dependency injector
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets the HTTP response code
+ *
+ *
+ * $response->setStatusCode(404, "Not Found");
+ *
+ */
+ public function setStatusCode($code, $message=null){ }
+
+
+ /**
+ * Returns the status code
+ *
+ *
+ * print_r($response->getStatusCode());
+ *
+ */
+ public function getStatusCode(){ }
+
+
+ /**
+ * Sets a headers bag for the response externally
+ */
+ public function setHeaders(\Phalcon\Http\Response\HeadersInterface $headers){ }
+
+
+ /**
+ * Returns headers set by the user
+ */
+ public function getHeaders(){ }
+
+
+ /**
+ * Sets a cookies bag for the response externally
+ */
+ public function setCookies(\Phalcon\Http\Response\CookiesInterface $cookies){ }
+
+
+ /**
+ * Returns coookies set by the user
+ *
+ * @return \Phalcon\Http\Response\CookiesInterface
+ */
+ public function getCookies(){ }
+
+
+ /**
+ * Overwrites a header in the response
+ *
+ *
+ * $response->setHeader("Content-Type", "text/plain");
+ *
+ *
+ * @param string name
+ * @param string value
+ * @return \Phalcon\Http\Response
+ */
+ public function setHeader($name, $value){ }
+
+
+ /**
+ * Send a raw header to the response
+ *
+ *
+ * $response->setRawHeader("HTTP/1.1 404 Not Found");
+ *
+ */
+ public function setRawHeader($header){ }
+
+
+ /**
+ * Resets all the stablished headers
+ */
+ public function resetHeaders(){ }
+
+
+ /**
+ * Sets a Expires header to use HTTP cache
+ *
+ *
+ * $this->response->setExpires(new DateTime());
+ *
+ */
+ public function setExpires(\DateTime $datetime){ }
+
+
+ /**
+ * Sends a Not-Modified response
+ */
+ public function setNotModified(){ }
+
+
+ /**
+ * Sets the response content-type mime, optionally the charset
+ *
+ *
+ * $response->setContentType('application/pdf');
+ * $response->setContentType('text/plain', 'UTF-8');
+ *
+ *
+ * @param string contentType
+ * @param string charset
+ * @return \Phalcon\Http\Response
+ */
+ public function setContentType($contentType, $charset=null){ }
+
+
+ /**
+ * Set a custom ETag
+ *
+ *
+ * $response->setEtag(md5(time()));
+ *
+ */
+ public function setEtag($etag){ }
+
+
+ /**
+ * Redirect by HTTP to another action or URL
+ *
+ *
+ * //Using a string redirect (internal/external)
+ * $response->redirect("posts/index");
+ * $response->redirect("http://en.wikipedia.org", true);
+ * $response->redirect("http://www.example.com/new-location", true, 301);
+ *
+ * //Making a redirection based on a named route
+ * $response->redirect(array(
+ * "for" => "index-lang",
+ * "lang" => "jp",
+ * "controller" => "index"
+ * ));
+ *
+ *
+ * @param string|array location
+ * @param boolean externalRedirect
+ * @param int statusCode
+ * @return \Phalcon\Http\Response
+ */
+ public function redirect($location=null, $externalRedirect=null, $statusCode=null){ }
+
+
+ /**
+ * Sets HTTP response body
+ *
+ *
+ * response->setContent("Hello!
");
+ *
+ */
+ public function setContent($content){ }
+
+
+ /**
+ * Sets HTTP response body. The parameter is automatically converted to JSON
+ *
+ *
+ * $response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param mixed content
+ * @param int jsonOptions
+ * @return \Phalcon\Http\Response
+ */
+ public function setJsonContent($content, $jsonOptions=null){ }
+
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string content
+ * @return \Phalcon\Http\Response
+ */
+ public function appendContent($content){ }
+
+
+ /**
+ * Gets the HTTP response body
+ */
+ public function getContent(){ }
+
+
+ /**
+ * Check if the response is already sent
+ */
+ public function isSent(){ }
+
+
+ /**
+ * Sends headers to the client
+ */
+ public function sendHeaders(){ }
+
+
+ /**
+ * Sends cookies to the client
+ */
+ public function sendCookies(){ }
+
+
+ /**
+ * Prints out HTTP response to the client
+ */
+ public function send(){ }
+
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string filePath
+ * @param string attachmentName
+ * @return \Phalcon\Http\Response
+ */
+ public function setFileToSend($filePath, $attachmentName=null, $attachment=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Http/Response/Cookies.php b/ide/2.0.2/Phalcon/Http/Response/Cookies.php
new file mode 100644
index 000000000..7a74f0ae2
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Http/Response/Cookies.php
@@ -0,0 +1,94 @@
+
+ * $image = new Phalcon\Image\Adapter\Imagick("upload/test.jpg");
+ * $image->resize(200, 200)->rotate(90)->crop(100, 100);
+ * if ($image->save()) {
+ * echo 'success';
+ * }
+ *
+ */
+
+ class Imagick extends \Phalcon\Image\Adapter implements \Phalcon\Image\AdapterInterface {
+
+ protected static $_version;
+
+ protected static $_checked;
+
+ /**
+ * Checks if Imagick is enabled
+ */
+ public static function check(){ }
+
+
+ /**
+ * \Phalcon\Image\Adapter\Imagick constructor
+ */
+ public function __construct($file, $width=null, $height=null){ }
+
+
+ /**
+ * Execute a resize.
+ */
+ protected function _resize($width, $height){ }
+
+
+ /**
+ * This method scales the images using liquid rescaling method. Only support Imagick
+ *
+ * @param int $width new width
+ * @param int $height new height
+ * @param int $deltaX How much the seam can traverse on x-axis. Passing 0 causes the seams to be straight.
+ * @param int $rigidity Introduces a bias for non-straight seams. This parameter is typically 0.
+ */
+ protected function _liquidRescale($width, $height, $deltaX, $rigidity){ }
+
+
+ /**
+ * Execute a crop.
+ */
+ protected function _crop($width, $height, $offsetX, $offsetY){ }
+
+
+ /**
+ * Execute a rotation.
+ */
+ protected function _rotate($degrees){ }
+
+
+ /**
+ * Execute a flip.
+ */
+ protected function _flip($direction){ }
+
+
+ /**
+ * Execute a sharpen.
+ */
+ protected function _sharpen($amount){ }
+
+
+ /**
+ * Execute a reflection.
+ */
+ protected function _reflection($height, $opacity, $fadeIn){ }
+
+
+ /**
+ * Execute a watermarking.
+ */
+ protected function _watermark(\Phalcon\Image\Adapter $image, $offsetX, $offsetY, $opacity){ }
+
+
+ /**
+ * Execute a text
+ */
+ protected function _text($text, $offsetX, $offsetY, $opacity, $r, $g, $b, $size, $fontfile){ }
+
+
+ /**
+ * Composite one image onto another
+ *
+ * @param Adapter $mask mask Image instance
+ */
+ protected function _mask(\Phalcon\Image\Adapter $image){ }
+
+
+ /**
+ * Execute a background.
+ */
+ protected function _background($r, $g, $b, $opacity){ }
+
+
+ /**
+ * Blur image
+ *
+ * @param int $radius Blur radius
+ */
+ protected function _blur($radius){ }
+
+
+ /**
+ * Pixelate image
+ *
+ * @param int $amount amount to pixelate
+ */
+ protected function _pixelate($amount){ }
+
+
+ /**
+ * Execute a save.
+ */
+ protected function _save($file, $quality){ }
+
+
+ /**
+ * Execute a render.
+ */
+ protected function _render($extension, $quality){ }
+
+
+ /**
+ * Destroys the loaded image to free up resources.
+ */
+ public function __destruct(){ }
+
+
+ /**
+ * Get instance
+ */
+ public function getInternalImInstance(){ }
+
+
+ /**
+ * Sets the limit for a particular resource in megabytes
+ * @param int type Refer to the list of resourcetype constants (@see http://php.net/manual/ru/imagick.constants.php#imagick.constants.resourcetypes.)
+ * @param int limit The resource limit. The unit depends on the type of the resource being limited.
+ */
+ public function setResourceLimit($type, $limit){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Image/AdapterInterface.php b/ide/2.0.2/Phalcon/Image/AdapterInterface.php
new file mode 100644
index 000000000..dfb1a72cc
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Image/AdapterInterface.php
@@ -0,0 +1,49 @@
+
+ * //Creates the autoloader
+ * $loader = new Loader();
+ *
+ * //Register some namespaces
+ * $loader->registerNamespaces(array(
+ * 'Example\Base' => 'vendor/example/base/',
+ * 'Example\Adapter' => 'vendor/example/adapter/',
+ * 'Example' => 'vendor/example/'
+ * ));
+ *
+ * //register autoloader
+ * $loader->register();
+ *
+ * //Requiring this class will automatically include file vendor/example/adapter/Some.php
+ * $adapter = Example\Adapter\Some();
+ *
+ */
+
+ class Loader implements \Phalcon\Events\EventsAwareInterface {
+
+ protected $_eventsManager;
+
+ protected $_foundPath;
+
+ protected $_checkedPath;
+
+ protected $_prefixes;
+
+ protected $_classes;
+
+ protected $_extensions;
+
+ protected $_namespaces;
+
+ protected $_directories;
+
+ protected $_registered;
+
+ /**
+ * \Phalcon\Loader constructor
+ */
+ public function __construct(){ }
+
+
+ /**
+ * Sets the events manager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager){ }
+
+
+ /**
+ * Returns the internal event manager
+ */
+ public function getEventsManager(){ }
+
+
+ /**
+ * Sets an array of file extensions that the loader must try in each attempt to locate the file
+ */
+ public function setExtensions($extensions){ }
+
+
+ /**
+ * Returns the file extensions registered in the loader
+ */
+ public function getExtensions(){ }
+
+
+ /**
+ * Register namespaces and their related directories
+ */
+ public function registerNamespaces($namespaces, $merge=null){ }
+
+
+ /**
+ * Returns the namespaces currently registered in the autoloader
+ */
+ public function getNamespaces(){ }
+
+
+ /**
+ * Register directories in which "not found" classes could be found
+ */
+ public function registerPrefixes($prefixes, $merge=null){ }
+
+
+ /**
+ * Returns the prefixes currently registered in the autoloader
+ */
+ public function getPrefixes(){ }
+
+
+ /**
+ * Register directories in which "not found" classes could be found
+ */
+ public function registerDirs($directories, $merge=null){ }
+
+
+ /**
+ * Returns the directories currently registered in the autoloader
+ */
+ public function getDirs(){ }
+
+
+ /**
+ * Register classes and their locations
+ */
+ public function registerClasses($classes, $merge=null){ }
+
+
+ /**
+ * Returns the class-map currently registered in the autoloader
+ */
+ public function getClasses(){ }
+
+
+ /**
+ * Register the autoload method
+ */
+ public function register(){ }
+
+
+ /**
+ * Unregister the autoload method
+ */
+ public function unregister(){ }
+
+
+ /**
+ * Autoloads the registered classes
+ */
+ public function autoLoad($className){ }
+
+
+ /**
+ * Get the path when a class was found
+ */
+ public function getFoundPath(){ }
+
+
+ /**
+ * Get the path the loader is checking for a path
+ */
+ public function getCheckedPath(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Loader/Exception.php b/ide/2.0.2/Phalcon/Loader/Exception.php
new file mode 100644
index 000000000..faaa6a83f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Loader/Exception.php
@@ -0,0 +1,7 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ * $logger->close();
+ *
+ */
+
+ class File extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface {
+
+ protected $_fileHandler;
+
+ protected $_path;
+
+ protected $_options;
+
+ /**
+ * File Path
+ */
+ public function getPath(){ }
+
+
+ /**
+ * \Phalcon\Logger\Adapter\File constructor
+ *
+ * @param string name
+ * @param array options
+ */
+ public function __construct($name, $options=null){ }
+
+
+ /**
+ * Returns the internal formatter
+ */
+ public function getFormatter(){ }
+
+
+ /**
+ * Writes the log to the file itself
+ */
+ public function logInternal($message, $type, $time, $context){ }
+
+
+ /**
+ * Closes the logger
+ */
+ public function close(){ }
+
+
+ /**
+ * Opens the internal file handler after unserialization
+ */
+ public function __wakeup(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Logger/Adapter/Firephp.php b/ide/2.0.2/Phalcon/Logger/Adapter/Firephp.php
new file mode 100644
index 000000000..ffd0a9ec6
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Logger/Adapter/Firephp.php
@@ -0,0 +1,49 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Firephp("");
+ * $logger->log(\Phalcon\Logger::ERROR, "This is an error");
+ * $logger->error("This is another error");
+ *
+ */
+
+ class Firephp extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface {
+
+ private static $_initialized;
+
+ private static $_index;
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter(){ }
+
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @see http://www.firephp.org/Wiki/Reference/Protocol
+ */
+ public function logInternal($message, $type, $time, $context){ }
+
+
+ /**
+ * Closes the logger
+ */
+ public function close(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Logger/Adapter/Stream.php b/ide/2.0.2/Phalcon/Logger/Adapter/Stream.php
new file mode 100644
index 000000000..752d90fa9
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Logger/Adapter/Stream.php
@@ -0,0 +1,49 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Stream("php://stderr");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+
+ class Stream extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface {
+
+ protected $_stream;
+
+ /**
+ * \Phalcon\Logger\Adapter\Stream constructor
+ *
+ * @param string name
+ * @param array options
+ */
+ public function __construct($name, $options=null){ }
+
+
+ /**
+ * Returns the internal formatter
+ */
+ public function getFormatter(){ }
+
+
+ /**
+ * Writes the log to the stream itself
+ */
+ public function logInternal($message, $type, $time, $context){ }
+
+
+ /**
+ * Closes the logger
+ */
+ public function close(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Logger/Adapter/Syslog.php b/ide/2.0.2/Phalcon/Logger/Adapter/Syslog.php
new file mode 100644
index 000000000..ab86e2b26
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Logger/Adapter/Syslog.php
@@ -0,0 +1,59 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Syslog("ident", array(
+ * 'option' => LOG_NDELAY,
+ * 'facility' => LOG_MAIL
+ * ));
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+
+ class Syslog extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface {
+
+ protected $_opened;
+
+ /**
+ * \Phalcon\Logger\Adapter\Syslog constructor
+ *
+ * @param string name
+ * @param array options
+ */
+ public function __construct($name, $options=null){ }
+
+
+ /**
+ * Returns the internal formatter
+ */
+ public function getFormatter(){ }
+
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string message
+ * @param int type
+ * @param int time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context){ }
+
+
+ /**
+ * Closes the logger
+ *
+ * @return boolean
+ */
+ public function close(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Logger/AdapterInterface.php b/ide/2.0.2/Phalcon/Logger/AdapterInterface.php
new file mode 100644
index 000000000..e635cb7a5
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Logger/AdapterInterface.php
@@ -0,0 +1,55 @@
+
+ *
+ * class Application extends \Phalcon\Mvc\Application
+ * {
+ *
+ * /**
+ * * Register the services here to make them general or register
+ * * in the ModuleDefinition to make them module-specific
+ * *\/
+ * protected function _registerServices()
+ * {
+ *
+ * }
+ *
+ * /**
+ * * This method registers all the modules in the application
+ * *\/
+ * public function main()
+ * {
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ * }
+ * }
+ *
+ * $application = new Application();
+ * $application->main();
+ *
+ *
+ */
+
+ class Application extends \Phalcon\Di\Injectable implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_defaultModule;
+
+ protected $_modules;
+
+ protected $_implicitView;
+
+ /**
+ * \Phalcon\Mvc\Application
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector=null){ }
+
+
+ /**
+ * By default. The view is implicitly buffering all the output
+ * You can full disable the view component using this method
+ */
+ public function useImplicitView($implicitView){ }
+
+
+ /**
+ * Register an array of modules present in the application
+ *
+ *
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ *
+ */
+ public function registerModules($modules, $merge=null){ }
+
+
+ /**
+ * Return the modules registered in the application
+ *
+ * @return array
+ */
+ public function getModules(){ }
+
+
+ /**
+ * Gets the module definition registered in the application via module name
+ *
+ * @param string name
+ * @return array|object
+ */
+ public function getModule($name){ }
+
+
+ /**
+ * Sets the module name to be used if the router doesn't return a valid module
+ */
+ public function setDefaultModule($defaultModule){ }
+
+
+ /**
+ * Returns the default module name
+ */
+ public function getDefaultModule(){ }
+
+
+ /**
+ * Handles a MVC request
+ *
+ * @param string uri
+ * @return \Phalcon\Http\ResponseInterface|boolean
+ */
+ public function handle($uri=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Application/Exception.php b/ide/2.0.2/Phalcon/Mvc/Application/Exception.php
new file mode 100644
index 000000000..4d8fafb38
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Application/Exception.php
@@ -0,0 +1,7 @@
+
+ * echo robot->readAttribute('name');
+ *
+ *
+ * @param string attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute){ }
+
+
+ /**
+ * Writes an attribute value by its name
+ *
+ *
+ * robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string attribute
+ * @param mixed value
+ */
+ public function writeAttribute($attribute, $value){ }
+
+
+ /**
+ * Returns a cloned collection
+ */
+ public static function cloneResult(\Phalcon\Mvc\CollectionInterface $collection, $document){ }
+
+
+ /**
+ * Returns a collection resultset
+ *
+ * @param array params
+ * @param \Phalcon\Mvc\Collection collection
+ * @param \MongoDb connection
+ * @param boolean unique
+ * @return array
+ */
+ protected static function _getResultset($params, \Phalcon\Mvc\CollectionInterface $collection, $connection, $unique){ }
+
+
+ /**
+ * Perform a count over a resultset
+ *
+ * @param array params
+ * @param \Phalcon\Mvc\Collection collection
+ * @param \MongoDb connection
+ * @return int
+ */
+ protected static function _getGroupResultset($params, \Phalcon\Mvc\Collection $collection, $connection){ }
+
+
+ /**
+ * Executes internal hooks before save a document
+ *
+ * @param \Phalcon\DiInterface dependencyInjector
+ * @param boolean disableEvents
+ * @param boolean exists
+ * @return boolean
+ */
+ final protected function _preSave($dependencyInjector, $disableEvents, $exists){ }
+
+
+ /**
+ * Executes internal events after save a document
+ */
+ final protected function _postSave($disableEvents, $success, $exists){ }
+
+
+ /**
+ * Executes validators on every validation call
+ *
+ *
+ *use \Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Collection
+ *{
+ *
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+ protected function validate(\Phalcon\Mvc\Model\ValidatorInterface $validator){ }
+
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ *
+ *use \Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Collection
+ *{
+ *
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+ public function validationHasFailed(){ }
+
+
+ /**
+ * Fires an internal event
+ */
+ public function fireEvent($eventName){ }
+
+
+ /**
+ * Fires an internal event that cancels the operation
+ */
+ public function fireEventCancel($eventName){ }
+
+
+ /**
+ * Cancel the current operation
+ */
+ protected function _cancelOperation($disableEvents){ }
+
+
+ /**
+ * Checks if the document exists in the collection
+ *
+ * @param \MongoCollection collection
+ * @return boolean
+ */
+ protected function _exists($collection){ }
+
+
+ /**
+ * Returns all the validation messages
+ *
+ *
+ *robot = new Robots();
+ *robot->type = 'mechanical';
+ *robot->name = 'Astro Boy';
+ *robot->year = 1952;
+ *if (robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach (robot->getMessages() as message) {
+ * echo message;
+ * }
+ *} else {
+ * echo "Great, a new robot was saved successfully!";
+ *}
+ *
+ */
+ public function getMessages(){ }
+
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ *
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ *
+ * public function beforeSave()
+ * {
+ * if (this->name == 'Peter') {
+ * message = new Message("Sorry, but a robot cannot be named Peter");
+ * this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message){ }
+
+
+ /**
+ * Creates/Updates a collection based on the values in the atributes
+ */
+ public function save(){ }
+
+
+ /**
+ * Find a document by its id (_id)
+ *
+ * @param string|\MongoId id
+ * @return \Phalcon\Mvc\Collection
+ */
+ public static function findById($id){ }
+
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ *
+ *
+ * //What's the first robot in the robots table?
+ * robot = Robots::findFirst();
+ * echo "The robot name is ", robot->name, "\n";
+ *
+ * //What's the first mechanical robot in robots table?
+ * robot = Robots::findFirst(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "The first mechanical robot name is ", robot->name, "\n";
+ *
+ * //Get first virtual robot ordered by name
+ * robot = Robots::findFirst(array(
+ * array("type" => "mechanical"),
+ * "order" => array("name" => 1)
+ * ));
+ * echo "The first virtual robot name is ", robot->name, "\n";
+ *
+ *
+ */
+ public static function findFirst($parameters=null){ }
+
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ *
+ *
+ * //How many robots are there?
+ * robots = Robots::find();
+ * echo "There are ", count(robots), "\n";
+ *
+ * //How many mechanical robots are there?
+ * robots = Robots::find(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "There are ", count(robots), "\n";
+ *
+ * //Get and print virtual robots ordered by name
+ * robots = Robots::findFirst(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1)
+ * ));
+ * foreach (robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ *
+ * //Get first 100 virtual robots ordered by name
+ * robots = Robots::find(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1),
+ * "limit" => 100
+ * ));
+ * foreach (robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ *
+ */
+ public static function find($parameters=null){ }
+
+
+ /**
+ * Perform a count over a collection
+ *
+ *
+ * echo 'There are ', Robots::count(), ' robots';
+ *
+ */
+ public static function count($parameters=null){ }
+
+
+ /**
+ * Perform an aggregation using the Mongo aggregation framework
+ */
+ public static function aggregate($parameters=null){ }
+
+
+ /**
+ * Allows to perform a summatory group for a column in the collection
+ *
+ * @param string field
+ * @param array conditions
+ * @param string finalize
+ * @return array
+ */
+ public static function summatory($field, $conditions=null, $finalize=null){ }
+
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ *
+ *
+ * robot = Robots::findFirst();
+ * robot->delete();
+ *
+ * foreach (Robots::find() as robot) {
+ * robot->delete();
+ * }
+ *
+ */
+ public function delete(){ }
+
+
+ /**
+ * Returns the instance as an array representation
+ *
+ *
+ * print_r(robot->to[]);
+ *
+ */
+ public function toArray(){ }
+
+
+ /**
+ * Serializes the object ignoring connections or protected properties
+ */
+ public function serialize(){ }
+
+
+ /**
+ * Unserializes the object from a serialized string
+ */
+ public function unserialize($data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Collection/Document.php b/ide/2.0.2/Phalcon/Mvc/Collection/Document.php
new file mode 100644
index 000000000..86986fbbf
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Collection/Document.php
@@ -0,0 +1,76 @@
+x or array[x].
+ */
+
+ class Document implements \ArrayAccess {
+
+ /**
+ * Checks whether an offset exists in the document
+ *
+ * @param int index
+ * @return boolean
+ */
+ public function offsetExists($index){ }
+
+
+ /**
+ * Returns the value of a field using the ArrayAccess interfase
+ *
+ * @param string index
+ * @return mixed
+ */
+ public function offsetGet($index){ }
+
+
+ /**
+ * Change a value using the ArrayAccess interface
+ *
+ * @param string index
+ * @param mixed value
+ * @param \Phalcon\Mvc\ModelInterface value
+ */
+ public function offsetSet($index, $value){ }
+
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string offset
+ */
+ public function offsetUnset($offset){ }
+
+
+ /**
+ * Reads an attribute value by its name
+ *
+ *
+ * echo robot->readAttribute('name');
+ *
+ *
+ * @param string attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute){ }
+
+
+ /**
+ * Writes an attribute value by its name
+ *
+ *
+ * robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string attribute
+ * @param mixed value
+ */
+ public function writeAttribute($attribute, $value){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Collection/Exception.php b/ide/2.0.2/Phalcon/Mvc/Collection/Exception.php
new file mode 100644
index 000000000..67d43d481
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Collection/Exception.php
@@ -0,0 +1,7 @@
+
+ * $di = new \Phalcon\Di();
+ *
+ * $di->set('collectionManager', function(){
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ *
+ * $robot = new Robots($di);
+ *
+ */
+
+ class Manager implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_initialized;
+
+ protected $_lastInitialized;
+
+ protected $_eventsManager;
+
+ protected $_customEventsManager;
+
+ protected $_connectionServices;
+
+ protected $_implicitObjectsIds;
+
+ /**
+ * Sets the DependencyInjector container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the DependencyInjector container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets the event manager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager){ }
+
+
+ /**
+ * Returns the internal event manager
+ */
+ public function getEventsManager(){ }
+
+
+ /**
+ * Sets a custom events manager for a specific model
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager){ }
+
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param \Phalcon\Mvc\CollectionInterface $model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model){ }
+
+
+ /**
+ * Initializes a model in the models manager
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model){ }
+
+
+ /**
+ * Check whether a model is already initialized
+ */
+ public function isInitialized($modelName){ }
+
+
+ /**
+ * Get the latest initialized model
+ */
+ public function getLastInitialized(){ }
+
+
+ /**
+ * Sets a connection service for a specific model
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService){ }
+
+
+ /**
+ * Sets whether a model must use implicit objects ids
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds){ }
+
+
+ /**
+ * Checks if a model is using implicit object ids
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model){ }
+
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param \Phalcon\Mvc\CollectionInterface $model
+ * @return \Mongo
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model){ }
+
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Collection/ManagerInterface.php b/ide/2.0.2/Phalcon/Mvc/Collection/ManagerInterface.php
new file mode 100644
index 000000000..d321b0019
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Collection/ManagerInterface.php
@@ -0,0 +1,37 @@
+
+ *dispatcher->forward(array('controller' => 'people', 'action' => 'index'));
+ * }
+ *
+ *}
+ *
+ *
+ */
+
+ abstract class Controller extends \Phalcon\Di\Injectable implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ /**
+ * \Phalcon\Mvc\Controller constructor
+ */
+ final public function __construct(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/ControllerInterface.php b/ide/2.0.2/Phalcon/Mvc/ControllerInterface.php
new file mode 100644
index 000000000..b376f7042
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/ControllerInterface.php
@@ -0,0 +1,7 @@
+
+ *
+ * $di = new \Phalcon\Di();
+ *
+ * $dispatcher = new \Phalcon\Mvc\Dispatcher();
+ *
+ * $dispatcher->setDI($di);
+ *
+ * $dispatcher->setControllerName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ *
+ * $controller = $dispatcher->dispatch();
+ *
+ *
+ */
+
+ class Dispatcher extends \Phalcon\Dispatcher implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\DispatcherInterface, \Phalcon\Mvc\DispatcherInterface {
+
+ const EXCEPTION_NO_DI = 0;
+
+ const EXCEPTION_CYCLIC_ROUTING = 1;
+
+ const EXCEPTION_HANDLER_NOT_FOUND = 2;
+
+ const EXCEPTION_INVALID_HANDLER = 3;
+
+ const EXCEPTION_INVALID_PARAMS = 4;
+
+ const EXCEPTION_ACTION_NOT_FOUND = 5;
+
+ protected $_handlerSuffix;
+
+ protected $_defaultHandler;
+
+ protected $_defaultAction;
+
+ /**
+ * Sets the default controller suffix
+ */
+ public function setControllerSuffix($controllerSuffix){ }
+
+
+ /**
+ * Sets the default controller name
+ */
+ public function setDefaultController($controllerName){ }
+
+
+ /**
+ * Sets the controller name to be dispatched
+ */
+ public function setControllerName($controllerName){ }
+
+
+ /**
+ * Gets last dispatched controller name
+ */
+ public function getControllerName(){ }
+
+
+ /**
+ * Gets previous dispatched controller name
+ */
+ public function getPreviousControllerName(){ }
+
+
+ /**
+ * Gets previous dispatched action name
+ */
+ public function getPreviousActionName(){ }
+
+
+ /**
+ * Throws an internal exception
+ */
+ protected function _throwDispatchException($message, $exceptionCode=null){ }
+
+
+ /**
+ * Handles a user exception
+ */
+ protected function _handleException(\Exception $exception){ }
+
+
+ /**
+ * Possible controller class name that will be located to dispatch the request
+ */
+ public function getControllerClass(){ }
+
+
+ /**
+ * Returns the lastest dispatched controller
+ */
+ public function getLastController(){ }
+
+
+ /**
+ * Returns the active controller in the dispatcher
+ */
+ public function getActiveController(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Dispatcher/Exception.php b/ide/2.0.2/Phalcon/Mvc/Dispatcher/Exception.php
new file mode 100644
index 000000000..4c0836e2f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Dispatcher/Exception.php
@@ -0,0 +1,7 @@
+
+ *
+ * $app = new \Phalcon\Mvc\Micro();
+ *
+ * $app->get('/say/welcome/{name}', function ($name) {
+ * echo "
+ * $app['request'] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string alias
+ * @param mixed definition
+ */
+ public function offsetSet($alias, $definition){ }
+
+
+ /**
+ * Allows to obtain a shared service in the internal services container using the array syntax
+ *
+ *
+ * var_dump($di['request']);
+ *
+ *
+ * @param string alias
+ * @return mixed
+ */
+ public function offsetGet($alias){ }
+
+
+ /**
+ * Removes a service from the internal services container using the array syntax
+ *
+ * @param string alias
+ */
+ public function offsetUnset($alias){ }
+
+
+ /**
+ * Appends a before middleware to be called before execute the route
+ *
+ * @param callable handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function before($handler){ }
+
+
+ /**
+ * Appends an 'after' middleware to be called after execute the route
+ *
+ * @param callable handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function after($handler){ }
+
+
+ /**
+ * Appends a 'finish' middleware to be called when the request is finished
+ *
+ * @param callable handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function finish($handler){ }
+
+
+ /**
+ * Returns the internal handlers attached to the application
+ *
+ * @return array
+ */
+ public function getHandlers(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Micro/Collection.php b/ide/2.0.2/Phalcon/Mvc/Micro/Collection.php
new file mode 100644
index 000000000..cd49ab46f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Micro/Collection.php
@@ -0,0 +1,184 @@
+
+ *
+ * $app = new \Phalcon\Mvc\Micro();
+ *
+ * $collection = new Collection();
+ *
+ * $collection->setHandler(new PostsController());
+ *
+ * $collection->get('/posts/edit/{id}', 'edit');
+ *
+ * $app->mount($collection);
+ *
+ *
+ *
+ */
+
+ class Collection implements \Phalcon\Mvc\Micro\CollectionInterface {
+
+ protected $_prefix;
+
+ protected $_lazy;
+
+ protected $_handler;
+
+ protected $_handlers;
+
+ /**
+ * Internal function to add a handler to the group
+ *
+ * @param string|array method
+ * @param string routePattern
+ * @param mixed handler
+ * @param string name
+ */
+ protected function _addMap($method, $routePattern, $handler, $name){ }
+
+
+ /**
+ * Sets a prefix for all routes added to the collection
+ */
+ public function setPrefix($prefix){ }
+
+
+ /**
+ * Returns the collection prefix if any
+ */
+ public function getPrefix(){ }
+
+
+ /**
+ * Returns the registered handlers
+ *
+ * @return array
+ */
+ public function getHandlers(){ }
+
+
+ /**
+ * Sets the main handler
+ *
+ * @param mixed handler
+ * @param boolean lazy
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function setHandler($handler, $lazy=null){ }
+
+
+ /**
+ * Sets if the main handler must be lazy loaded
+ */
+ public function setLazy($lazy){ }
+
+
+ /**
+ * Returns if the main handler must be lazy loaded
+ */
+ public function isLazy(){ }
+
+
+ /**
+ * Returns the main handler
+ *
+ * @return mixed
+ */
+ public function getHandler(){ }
+
+
+ /**
+ * Maps a route to a handler
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @param string name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function map($routePattern, $handler, $name=null){ }
+
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is GET
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @param string name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function get($routePattern, $handler, $name=null){ }
+
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is POST
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @param string name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function post($routePattern, $handler, $name=null){ }
+
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PUT
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @param string name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function put($routePattern, $handler, $name=null){ }
+
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PATCH
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @param string name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function patch($routePattern, $handler, $name=null){ }
+
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is HEAD
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @param string name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function head($routePattern, $handler, $name=null){ }
+
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is DELETE
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @param string name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function delete($routePattern, $handler, $name=null){ }
+
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is OPTIONS
+ *
+ * @param string routePattern
+ * @param callable handler
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function options($routePattern, $handler, $name=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Micro/CollectionInterface.php b/ide/2.0.2/Phalcon/Mvc/Micro/CollectionInterface.php
new file mode 100644
index 000000000..05b24c65e
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Micro/CollectionInterface.php
@@ -0,0 +1,52 @@
+Phalcon\Mvc\Model connects business objects and database tables to create
+ * a persistable domain model where logic and data are presented in one wrapping.
+ * It‘s an implementation of the object-relational mapping (ORM).
+ *
+ * A model represents the information (data) of the application and the rules to manipulate that data. + * Models are primarily used for managing the rules of interaction with a corresponding database table. + * In most cases, each table in your database will correspond to one model in your application. + * The bulk of your application's business logic will be concentrated in the models.
+ * + *Phalcon\Mvc\Model is the first ORM written in C-language for PHP, giving to developers high performance + * when interacting with databases while is also easy to use.
+ * + *
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can store robots: ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ */
+
+ abstract class Model implements \Phalcon\Mvc\ModelInterface, \Phalcon\Mvc\Model\ResultInterface, \Phalcon\Di\InjectionAwareInterface, \Serializable {
+
+ const OP_NONE = 0;
+
+ const OP_CREATE = 1;
+
+ const OP_UPDATE = 2;
+
+ const OP_DELETE = 3;
+
+ const DIRTY_STATE_PERSISTENT = 0;
+
+ const DIRTY_STATE_TRANSIENT = 1;
+
+ const DIRTY_STATE_DETACHED = 2;
+
+ protected $_dependencyInjector;
+
+ protected $_modelsManager;
+
+ protected $_modelsMetaData;
+
+ protected $_errorMessages;
+
+ protected $_operationMade;
+
+ protected $_dirtyState;
+
+ protected $_transaction;
+
+ protected $_uniqueKey;
+
+ protected $_uniqueParams;
+
+ protected $_uniqueTypes;
+
+ protected $_skipped;
+
+ protected $_related;
+
+ protected $_snapshot;
+
+ /**
+ * \Phalcon\Mvc\Model constructor
+ */
+ final public function __construct(\Phalcon\DiInterface $dependencyInjector=null, \Phalcon\Mvc\Model\ManagerInterface $modelsManager=null){ }
+
+
+ /**
+ * Sets the dependency injection container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the dependency injection container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets a custom events manager
+ */
+ protected function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager){ }
+
+
+ /**
+ * Returns the custom events manager
+ */
+ protected function getEventsManager(){ }
+
+
+ /**
+ * Returns the models meta-data service related to the entity instance
+ */
+ public function getModelsMetaData(){ }
+
+
+ /**
+ * Returns the models manager related to the entity instance
+ */
+ public function getModelsManager(){ }
+
+
+ /**
+ * Sets a transaction related to the Model instance
+ *
+ *
+ *use \Phalcon\Mvc\Model\Transaction\Manager as TxManager;
+ *use \Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
+ *
+ *try {
+ *
+ * $txManager = new TxManager();
+ *
+ * $transaction = $txManager->get();
+ *
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ *
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Robot part cannot be saved");
+ * }
+ *
+ * $transaction->commit();
+ *
+ *} catch (TxFailed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ *}
+ *
+ *
+ */
+ public function setTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction){ }
+
+
+ /**
+ * Sets table name which model should be mapped
+ */
+ protected function setSource($source){ }
+
+
+ /**
+ * Returns table name mapped in the model
+ */
+ public function getSource(){ }
+
+
+ /**
+ * Sets schema name where table mapped is located
+ */
+ protected function setSchema($schema){ }
+
+
+ /**
+ * Returns schema name where table mapped is located
+ */
+ public function getSchema(){ }
+
+
+ /**
+ * Sets the DependencyInjection connection service name
+ */
+ public function setConnectionService($connectionService){ }
+
+
+ /**
+ * Sets the DependencyInjection connection service name used to read data
+ */
+ public function setReadConnectionService($connectionService){ }
+
+
+ /**
+ * Sets the DependencyInjection connection service name used to write data
+ */
+ public function setWriteConnectionService($connectionService){ }
+
+
+ /**
+ * Returns the DependencyInjection connection service name used to read data related the model
+ */
+ public function getReadConnectionService(){ }
+
+
+ /**
+ * Returns the DependencyInjection connection service name used to write data related to the model
+ */
+ public function getWriteConnectionService(){ }
+
+
+ /**
+ * Sets the dirty state of the object using one of the DIRTY_STATE_* constants
+ */
+ public function setDirtyState($dirtyState){ }
+
+
+ /**
+ * Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not
+ */
+ public function getDirtyState(){ }
+
+
+ /**
+ * Gets the connection used to read data for the model
+ */
+ public function getReadConnection(){ }
+
+
+ /**
+ * Gets the connection used to write data to the model
+ */
+ public function getWriteConnection(){ }
+
+
+ /**
+ * Assigns values to a model from an array
+ *
+ *
+ * $robot->assign(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ * //assign by db row, column map needed
+ * $robot->assign($dbRow, array(
+ * 'db_type' => 'type',
+ * 'db_name' => 'name',
+ * 'db_year' => 'year'
+ * ));
+ *
+ * //allow assign only name and year
+ * $robot->assign($_POST, null, array('name', 'year');
+ *
+ *
+ *
+ * @param array data
+ * @param array dataColumnMap array to transform keys of data to another
+ * @param array whiteList
+ * @return \Phalcon\Mvc\Model
+ */
+ public function assign($data, $dataColumnMap=null, $whiteList=null){ }
+
+
+ /**
+ * Assigns values to a model from an array returning a new model.
+ *
+ *
+ *$robot = \Phalcon\Mvc\Model::cloneResultMap(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ *));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface|Phalcon\Mvc\Model\Row base
+ * @param array data
+ * @param array columnMap
+ * @param int dirtyState
+ * @param boolean keepSnapshots
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function cloneResultMap($base, $data, $columnMap, $dirtyState=null, $keepSnapshots=null){ }
+
+
+ /**
+ * Returns an hydrated result based on the data and the column map
+ *
+ * @param array data
+ * @param array columnMap
+ * @param int hydrationMode
+ * @return mixed
+ */
+ public static function cloneResultMapHydrate($data, $columnMap, $hydrationMode){ }
+
+
+ /**
+ * Assigns values to a model from an array returning a new model
+ *
+ *
+ *$robot = \Phalcon\Mvc\Model::cloneResult(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ *));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface $base
+ * @param array data
+ * @param int dirtyState
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public static function cloneResult(\Phalcon\Mvc\ModelInterface $base, $data, $dirtyState=null){ }
+
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ *
+ *
+ * //How many robots are there?
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ *
+ * //How many mechanical robots are there?
+ * $robots = Robots::find("type='mechanical'");
+ * echo "There are ", count($robots), "\n";
+ *
+ * //Get and print virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name", "limit" => 100));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ *
+ * @param array parameters
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public static function find($parameters=null){ }
+
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ *
+ *
+ * //What's the first robot in robots table?
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name;
+ *
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst("type='mechanical'");
+ * echo "The first mechanical robot name is ", $robot->name;
+ *
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array("type='virtual'", "order" => "name"));
+ * echo "The first virtual robot name is ", $robot->name;
+ *
+ *
+ *
+ * @param array parameters
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function findFirst($parameters=null){ }
+
+
+ /**
+ * Create a criteria for a specific model
+ */
+ public static function query(\Phalcon\DiInterface $dependencyInjector=null){ }
+
+
+ /**
+ * Checks if the current record already exists or not
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface metaData
+ * @param \Phalcon\Db\AdapterInterface connection
+ * @param string|array table
+ * @return boolean
+ */
+ protected function _exists(\Phalcon\Mvc\Model\MetaDataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table=null){ }
+
+
+ /**
+ * Generate a PHQL SELECT statement for an aggregate
+ *
+ * @param string function
+ * @param string alias
+ * @param array parameters
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected static function _groupResult($functionName, $alias, $parameters){ }
+
+
+ /**
+ * Allows to count how many records match the specified conditions
+ *
+ *
+ *
+ * //How many robots are there?
+ * $number = Robots::count();
+ * echo "There are ", $number, "\n";
+ *
+ * //How many mechanical robots are there?
+ * $number = Robots::count("type='mechanical'");
+ * echo "There are ", $number, " mechanical robots\n";
+ *
+ *
+ *
+ * @param array parameters
+ * @return mixed
+ */
+ public static function count($parameters=null){ }
+
+
+ /**
+ * Allows to calculate a summatory on a column that match the specified conditions
+ *
+ *
+ *
+ * //How much are all robots?
+ * $sum = Robots::sum(array('column' => 'price'));
+ * echo "The total price of robots is ", $sum, "\n";
+ *
+ * //How much are mechanical robots?
+ * $sum = Robots::sum(array("type='mechanical'", 'column' => 'price'));
+ * echo "The total price of mechanical robots is ", $sum, "\n";
+ *
+ *
+ *
+ * @param array parameters
+ * @return mixed
+ */
+ public static function sum($parameters=null){ }
+
+
+ /**
+ * Allows to get the maximum value of a column that match the specified conditions
+ *
+ *
+ *
+ * //What is the maximum robot id?
+ * $id = Robots::maximum(array('column' => 'id'));
+ * echo "The maximum robot id is: ", $id, "\n";
+ *
+ * //What is the maximum id of mechanical robots?
+ * $sum = Robots::maximum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The maximum robot id of mechanical robots is ", $id, "\n";
+ *
+ *
+ *
+ * @param array parameters
+ * @return mixed
+ */
+ public static function maximum($parameters=null){ }
+
+
+ /**
+ * Allows to get the minimum value of a column that match the specified conditions
+ *
+ *
+ *
+ * //What is the minimum robot id?
+ * $id = Robots::minimum(array('column' => 'id'));
+ * echo "The minimum robot id is: ", $id;
+ *
+ * //What is the minimum id of mechanical robots?
+ * $sum = Robots::minimum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The minimum robot id of mechanical robots is ", $id;
+ *
+ *
+ *
+ * @param array parameters
+ * @return mixed
+ */
+ public static function minimum($parameters=null){ }
+
+
+ /**
+ * Allows to calculate the average value on a column matching the specified conditions
+ *
+ *
+ *
+ * //What's the average price of robots?
+ * $average = Robots::average(array('column' => 'price'));
+ * echo "The average price is ", $average, "\n";
+ *
+ * //What's the average price of mechanical robots?
+ * $average = Robots::average(array("type='mechanical'", 'column' => 'price'));
+ * echo "The average price of mechanical robots is ", $average, "\n";
+ *
+ *
+ *
+ * @param array parameters
+ * @return double
+ */
+ public static function average($parameters=null){ }
+
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ */
+ public function fireEvent($eventName){ }
+
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ * This method stops if one of the callbacks/listeners returns boolean false
+ */
+ public function fireEventCancel($eventName){ }
+
+
+ /**
+ * Cancel the current operation
+ */
+ protected function _cancelOperation(){ }
+
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ *
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ *
+ * public function beforeSave()
+ * {
+ * if ($this->name == 'Peter') {
+ * $message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage($message);
+ * }
+ * }
+ * }
+ *
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message){ }
+
+
+ /**
+ * Executes validators on every validation call
+ *
+ *
+ *use \Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+ protected function validate(\Phalcon\Mvc\Model\ValidatorInterface $validator){ }
+
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ *
+ *use \Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+ public function validationHasFailed(){ }
+
+
+ /**
+ * Returns all the validation messages
+ *
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo $message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ */
+ public function getMessages($filter=null){ }
+
+
+ /**
+ * Reads "belongs to" relations and check the virtual foreign keys when inserting or updating records
+ * to verify that inserted/updated values are present in the related entity
+ */
+ protected function _checkForeignKeysRestrict(){ }
+
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (cascade) when deleting records
+ */
+ protected function _checkForeignKeysReverseCascade(){ }
+
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (restrict) when deleting records
+ */
+ protected function _checkForeignKeysReverseRestrict(){ }
+
+
+ /**
+ * Executes internal hooks before save a record
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface metaData
+ * @param boolean exists
+ * @param string identityField
+ * @return boolean
+ */
+ protected function _preSave(\Phalcon\Mvc\Model\MetaDataInterface $metaData, $exists, $identityField){ }
+
+
+ /**
+ * Executes internal events after save a record
+ */
+ protected function _postSave($success, $exists){ }
+
+
+ /**
+ * Sends a pre-build INSERT SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface metaData
+ * @param \Phalcon\Db\AdapterInterface connection
+ * @param string|array table
+ * @param boolean|string identityField
+ * @return boolean
+ */
+ protected function _doLowInsert(\Phalcon\Mvc\Model\MetaDataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table, $identityField){ }
+
+
+ /**
+ * Sends a pre-build UPDATE SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetaDataInterface metaData
+ * @param \Phalcon\Db\AdapterInterface connection
+ * @param string|array table
+ * @return boolean
+ */
+ protected function _doLowUpdate(\Phalcon\Mvc\Model\MetaDataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table){ }
+
+
+ /**
+ * Saves related records that must be stored prior to save the master record
+ *
+ * @param \Phalcon\Db\AdapterInterface connection
+ * @param \Phalcon\Mvc\ModelInterface[] related
+ * @return boolean
+ */
+ protected function _preSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related){ }
+
+
+ /**
+ * Save the related records assigned in the has-one/has-many relations
+ *
+ * @param \Phalcon\Db\AdapterInterface connection
+ * @param \Phalcon\Mvc\ModelInterface[] related
+ * @return boolean
+ */
+ protected function _postSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related){ }
+
+
+ /**
+ * Inserts or updates a model instance. Returning true on success or false otherwise.
+ *
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->save();
+ *
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->save();
+ *
+ *
+ * @param array data
+ * @param array whiteList
+ * @return boolean
+ */
+ public function save($data=null, $whiteList=null){ }
+
+
+ /**
+ * Inserts a model instance. If the instance already exists in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->create();
+ *
+ * //Passing an array to create
+ * $robot = new Robots();
+ * $robot->create(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astroy Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param array data
+ * @param array whiteList
+ * @return boolean
+ */
+ public function create($data=null, $whiteList=null){ }
+
+
+ /**
+ * Updates a model instance. If the instance doesn't exist in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ *
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->update();
+ *
+ *
+ * @param array data
+ * @param array whiteList
+ * @return boolean
+ */
+ public function update($data=null, $whiteList=null){ }
+
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ *
+ *$robot = Robots::findFirst("id=100");
+ *$robot->delete();
+ *
+ *foreach (Robots::find("type = 'mechanical'") as $robot) {
+ * $robot->delete();
+ *}
+ *
+ */
+ public function delete(){ }
+
+
+ /**
+ * Returns the type of the latest operation performed by the ORM
+ * Returns one of the OP_* class constants
+ */
+ public function getOperationMade(){ }
+
+
+ /**
+ * Refreshes the model attributes re-querying the record from the database
+ */
+ public function refresh(){ }
+
+
+ /**
+ * Skips the current operation forcing a success state
+ */
+ public function skipOperation($skip){ }
+
+
+ /**
+ * Reads an attribute value by its name
+ *
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute){ }
+
+
+ /**
+ * Writes an attribute value by its name
+ *
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string attribute
+ * @param mixed value
+ */
+ public function writeAttribute($attribute, $value){ }
+
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT/UPDATE statement
+ *
+ *
+ *skipAttributes(array('price'));
+ * }
+ *
+ *}
+ *
+ */
+ protected function skipAttributes($attributes){ }
+
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT statement
+ *
+ *
+ *skipAttributesOnCreate(array('created_at'));
+ * }
+ *
+ *}
+ *
+ */
+ protected function skipAttributesOnCreate($attributes){ }
+
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ *
+ *skipAttributesOnUpdate(array('modified_in'));
+ * }
+ *
+ *}
+ *
+ */
+ protected function skipAttributesOnUpdate($attributes){ }
+
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ *
+ *hasOne('id', 'RobotsDescription', 'robots_id');
+ * }
+ *
+ *}
+ *
+ *
+ * @param mixed fields
+ * @param string referenceModel
+ * @param mixed referencedFields
+ * @param array options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasOne($fields, $referenceModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Setup a relation reverse 1-1 between two models
+ *
+ *
+ *belongsTo('robots_id', 'Robots', 'id');
+ * }
+ *
+ *}
+ *
+ *
+ * @param mixed fields
+ * @param string referenceModel
+ * @param mixed referencedFields
+ * @param array options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function belongsTo($fields, $referenceModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ *
+ *hasMany('id', 'RobotsParts', 'robots_id');
+ * }
+ *
+ *}
+ *
+ *
+ * @param mixed fields
+ * @param string referenceModel
+ * @param mixed referencedFields
+ * @param array options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasMany($fields, $referenceModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Setup a relation n-n between two models through an intermediate relation
+ *
+ *
+ *hasManyToMany(
+ * 'id',
+ * 'RobotsParts',
+ * 'robots_id',
+ * 'parts_id',
+ * 'Parts',
+ * 'id'
+ * );
+ * }
+ *
+ *}
+ *
+ *
+ * @param string|array fields
+ * @param string intermediateModel
+ * @param string|array intermediateFields
+ * @param string|array intermediateReferencedFields
+ * @param string referencedModel
+ * @param string|array referencedFields
+ * @param array options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasManyToMany($fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referenceModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Setups a behavior in a model
+ *
+ *
+ *addBehavior(new Timestampable(array(
+ * 'onCreate' => array(
+ * 'field' => 'created_at',
+ * 'format' => 'Y-m-d'
+ * )
+ * )));
+ * }
+ *
+ *}
+ *
+ */
+ public function addBehavior(\Phalcon\Mvc\Model\BehaviorInterface $behavior){ }
+
+
+ /**
+ * Sets if the model must keep the original record snapshot in memory
+ *
+ *
+ *keepSnapshots(true);
+ * }
+ *
+ *}
+ *
+ */
+ protected function keepSnapshots($keepSnapshot){ }
+
+
+ /**
+ * Sets the record's snapshot data.
+ * This method is used internally to set snapshot data when the model was set up to keep snapshot data
+ *
+ * @param array data
+ * @param array columnMap
+ */
+ public function setSnapshotData($data, $columnMap=null){ }
+
+
+ /**
+ * Checks if the object has internal snapshot data
+ */
+ public function hasSnapshotData(){ }
+
+
+ /**
+ * Returns the internal snapshot data
+ */
+ public function getSnapshotData(){ }
+
+
+ /**
+ * Check if a specific attribute has changed
+ * This only works if the model is keeping data snapshots
+ *
+ * @param string|array fieldName
+ */
+ public function hasChanged($fieldName=null){ }
+
+
+ /**
+ * Returns a list of changed values
+ */
+ public function getChangedFields(){ }
+
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ *
+ *useDynamicUpdate(true);
+ * }
+ *
+ *}
+ *
+ */
+ protected function useDynamicUpdate($dynamicUpdate){ }
+
+
+ /**
+ * Returns related records based on defined relations
+ *
+ * @param string alias
+ * @param array arguments
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getRelated($alias, $arguments=null){ }
+
+
+ /**
+ * Returns related records defined relations depending on the method name
+ *
+ * @param string modelName
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ */
+ protected function _getRelatedRecords($modelName, $method, $arguments){ }
+
+
+ /**
+ * Handles method calls when a method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ */
+ public function __call($method, $arguments=null){ }
+
+
+ /**
+ * Handles method calls when a static method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ */
+ public static function __callStatic($method, $arguments=null){ }
+
+
+ /**
+ * Magic method to assign values to the the model
+ *
+ * @param string property
+ * @param mixed value
+ */
+ public function __set($property, $value){ }
+
+
+ /**
+ * Magic method to get related records using the relation alias as a property
+ *
+ * @param string property
+ * @return \Phalcon\Mvc\Model\Resultset|Phalcon\Mvc\Model
+ */
+ public function __get($property){ }
+
+
+ /**
+ * Magic method to check if a property is a valid relation
+ */
+ public function __isset($property){ }
+
+
+ /**
+ * Serializes the object ignoring connections, services, related objects or static properties
+ */
+ public function serialize(){ }
+
+
+ /**
+ * Unserializes the object from a serialized string
+ */
+ public function unserialize($data){ }
+
+
+ /**
+ * Returns a simple representation of the object that can be used with var_dump
+ *
+ *
+ * var_dump($robot->dump());
+ *
+ */
+ public function dump(){ }
+
+
+ /**
+ * Returns the instance as an array representation
+ *
+ *
+ * print_r($robot->toArray());
+ *
+ *
+ * @param array $columns
+ * @return array
+ */
+ public function toArray($columns=null){ }
+
+
+ /**
+ * Enables/disables options in the ORM
+ */
+ public static function setup($options){ }
+
+
+ /**
+ * Reset a model instance data
+ */
+ public function reset(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Behavior.php b/ide/2.0.2/Phalcon/Mvc/Model/Behavior.php
new file mode 100644
index 000000000..c8cabb704
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Behavior.php
@@ -0,0 +1,54 @@
+
+ *$robots = Robots::query()
+ * ->where("type = :type:")
+ * ->andWhere("year < 2000")
+ * ->bind(array("type" => "mechanical"))
+ * ->limit(5, 10)
+ * ->orderBy("name")
+ * ->execute();
+ *
+ */
+
+ class Criteria implements \Phalcon\Mvc\Model\CriteriaInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_model;
+
+ protected $_params;
+
+ protected $_bindParams;
+
+ protected $_bindTypes;
+
+ protected $_hiddenParamNumber;
+
+ /**
+ * Sets the DependencyInjector container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the DependencyInjector container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Set a model on which the query will be executed
+ */
+ public function setModelName($modelName){ }
+
+
+ /**
+ * Returns an internal model name on which the criteria will be applied
+ */
+ public function getModelName(){ }
+
+
+ /**
+ * Sets the bound parameters in the criteria
+ * This method replaces all previously set bound parameters
+ */
+ public function bind($bindParams){ }
+
+
+ /**
+ * Sets the bind types in the criteria
+ * This method replaces all previously set bound parameters
+ */
+ public function bindTypes($bindTypes){ }
+
+
+ /**
+ * Sets the columns to be queried
+ *
+ *
+ * $criteria->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array columns
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function columns($columns){ }
+
+
+ /**
+ * Adds a INNER join to the query
+ *
+ *
+ * $criteria->join('Robots');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'LEFT');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @param string type
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function join($model, $conditions=null, $alias=null, $type=null){ }
+
+
+ /**
+ * Adds a INNER join to the query
+ *
+ *
+ * $criteria->innerJoin('Robots');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function innerJoin($model, $conditions=null, $alias=null){ }
+
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ *
+ * $criteria->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function leftJoin($model, $conditions=null, $alias=null){ }
+
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ *
+ * $criteria->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function rightJoin($model, $conditions=null, $alias=null){ }
+
+
+ /**
+ * Sets the conditions parameter in the criteria
+ *
+ * @param string conditions
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function where($conditions, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Appends a condition to the current conditions using an AND operator (deprecated)
+ *
+ * @deprecated 1.0.0
+ * @see \Phalcon\Mvc\Model\Criteria::andWhere()
+ * @param string conditions
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function addWhere($conditions, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Appends a condition to the current conditions using an AND operator
+ *
+ * @param string conditions
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function andWhere($conditions, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Appends a condition to the current conditions using an OR operator
+ *
+ * @param string conditions
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function orWhere($conditions, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ *
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string expr
+ * @param mixed minimum
+ * @param mixed maximum
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function betweenWhere($expr, $minimum, $maximum){ }
+
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string expr
+ * @param mixed minimum
+ * @param mixed maximum
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum){ }
+
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ */
+ public function inWhere($expr, $values){ }
+
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ */
+ public function notInWhere($expr, $values){ }
+
+
+ /**
+ * Adds the conditions parameter to the criteria
+ */
+ public function conditions($conditions){ }
+
+
+ /**
+ * Adds the order-by parameter to the criteria (deprecated)
+ *
+ * @deprecated 1.2.1
+ * @see \Phalcon\Mvc\Model\Criteria::orderBy()
+ */
+ public function order($orderColumns){ }
+
+
+ /**
+ * Adds the order-by parameter to the criteria
+ */
+ public function orderBy($orderColumns){ }
+
+
+ /**
+ * Adds the limit parameter to the criteria
+ *
+ * @param int limit
+ * @param int offset
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function limit($limit, $offset=null){ }
+
+
+ /**
+ * Adds the "for_update" parameter to the criteria
+ */
+ public function forUpdate($forUpdate=null){ }
+
+
+ /**
+ * Adds the "shared_lock" parameter to the criteria
+ */
+ public function sharedLock($sharedLock=null){ }
+
+
+ /**
+ * Sets the cache options in the criteria
+ * This method replaces all previously set cache options
+ */
+ public function cache($cache){ }
+
+
+ /**
+ * Returns the conditions parameter in the criteria
+ */
+ public function getWhere(){ }
+
+
+ /**
+ * Returns the columns to be queried
+ *
+ * @return string|array|null
+ */
+ public function getColumns(){ }
+
+
+ /**
+ * Returns the conditions parameter in the criteria
+ */
+ public function getConditions(){ }
+
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit(){ }
+
+
+ /**
+ * Returns the order parameter in the criteria
+ */
+ public function getOrder(){ }
+
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams(){ }
+
+
+ /**
+ * Builds a \Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data){ }
+
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ */
+ public function execute(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/CriteriaInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/CriteriaInterface.php
new file mode 100644
index 000000000..734a3abd1
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/CriteriaInterface.php
@@ -0,0 +1,76 @@
+
+ * $di = new \Phalcon\DI();
+ *
+ * $di->set('modelsManager', function() {
+ * return new \Phalcon\Mvc\Model\Manager();
+ * });
+ *
+ * $robot = new Robots($di);
+ *
+ */
+
+ class Manager implements \Phalcon\Mvc\Model\ManagerInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_eventsManager;
+
+ protected $_customEventsManager;
+
+ protected $_readConnectionServices;
+
+ protected $_writeConnectionServices;
+
+ protected $_aliases;
+
+ protected $_hasMany;
+
+ protected $_hasManySingle;
+
+ protected $_hasOne;
+
+ protected $_hasOneSingle;
+
+ protected $_belongsTo;
+
+ protected $_belongsToSingle;
+
+ protected $_hasManyToMany;
+
+ protected $_hasManyToManySingle;
+
+ protected $_initialized;
+
+ protected $_sources;
+
+ protected $_schemas;
+
+ protected $_behaviors;
+
+ protected $_lastInitialized;
+
+ protected $_lastQuery;
+
+ protected $_reusable;
+
+ protected $_keepSnapshots;
+
+ protected $_dynamicUpdate;
+
+ protected $_namespaceAliases;
+
+ /**
+ * Sets the DependencyInjector container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the DependencyInjector container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets a global events manager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager){ }
+
+
+ /**
+ * Returns the internal event manager
+ */
+ public function getEventsManager(){ }
+
+
+ /**
+ * Sets a custom events manager for a specific model
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Events\ManagerInterface $eventsManager){ }
+
+
+ /**
+ * Returns a custom events manager related to a model
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Initializes a model in the model manager
+ */
+ public function initialize(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Check whether a model is already initialized
+ */
+ public function isInitialized($modelName){ }
+
+
+ /**
+ * Get last initialized model
+ */
+ public function getLastInitialized(){ }
+
+
+ /**
+ * Loads a model throwing an exception if it doesn't exist
+ */
+ public function load($modelName, $newInstance=null){ }
+
+
+ /**
+ * Sets the mapped source for a model
+ */
+ public function setModelSource(\Phalcon\Mvc\ModelInterface $model, $source){ }
+
+
+ /**
+ * Returns the mapped source for a model
+ */
+ public function getModelSource(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Sets the mapped schema for a model
+ */
+ public function setModelSchema(\Phalcon\Mvc\ModelInterface $model, $schema){ }
+
+
+ /**
+ * Returns the mapped schema for a model
+ */
+ public function getModelSchema(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Sets both write and read connection service for a model
+ */
+ public function setConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService){ }
+
+
+ /**
+ * Sets write connection service for a model
+ */
+ public function setWriteConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService){ }
+
+
+ /**
+ * Sets read connection service for a model
+ */
+ public function setReadConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService){ }
+
+
+ /**
+ * Returns the connection to read data related to a model
+ */
+ public function getReadConnection(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the connection to write data related to a model
+ */
+ public function getWriteConnection(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the connection to read or write data related to a model depending on the connection services.
+ */
+ protected function _getConnection(\Phalcon\Mvc\ModelInterface $model, $connectionServices){ }
+
+
+ /**
+ * Returns the connection service name used to read data related to a model
+ */
+ public function getReadConnectionService(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the connection service name used to write data related to a model
+ */
+ public function getWriteConnectionService(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the connection service name used to read or write data related to a model depending on the connection services
+ */
+ public function _getConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionServices){ }
+
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ */
+ public function missingMethod(\Phalcon\Mvc\ModelInterface $model, $eventName, $data){ }
+
+
+ /**
+ * Binds a behavior to a model
+ */
+ public function addBehavior(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Mvc\Model\BehaviorInterface $behavior){ }
+
+
+ /**
+ * Sets if a model must keep snapshots
+ */
+ public function keepSnapshots(\Phalcon\Mvc\ModelInterface $model, $keepSnapshots){ }
+
+
+ /**
+ * Checks if a model is keeping snapshots for the queried records
+ */
+ public function isKeepingSnapshots(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ */
+ public function useDynamicUpdate(\Phalcon\Mvc\ModelInterface $model, $dynamicUpdate){ }
+
+
+ /**
+ * Checks if a model is using dynamic update instead of all-field update
+ */
+ public function isUsingDynamicUpdate(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * @param \Phalcon\Mvc\Model model
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasOne(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Setup a relation reverse many to one between two models
+ *
+ * @param \Phalcon\Mvc\Model model
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addBelongsTo(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * @param Phalcon\Mvc\ModelInterface model
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ */
+ public function addHasMany(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Setups a relation n-m between two models
+ *
+ * @param Phalcon\Mvc\ModelInterface model
+ * @param string fields
+ * @param string intermediateModel
+ * @param string intermediateFields
+ * @param string intermediateReferencedFields
+ * @param string referencedModel
+ * @param string referencedFields
+ * @param array options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasManyToMany(\Phalcon\Mvc\ModelInterface $model, $fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referencedModel, $referencedFields, $options=null){ }
+
+
+ /**
+ * Checks whether a model has a belongsTo relation with another model
+ */
+ public function existsBelongsTo($modelName, $modelRelation){ }
+
+
+ /**
+ * Checks whether a model has a hasMany relation with another model
+ */
+ public function existsHasMany($modelName, $modelRelation){ }
+
+
+ /**
+ * Checks whether a model has a hasOne relation with another model
+ */
+ public function existsHasOne($modelName, $modelRelation){ }
+
+
+ /**
+ * Checks whether a model has a hasManyToMany relation with another model
+ */
+ public function existsHasManyToMany($modelName, $modelRelation){ }
+
+
+ /**
+ * Returns a relation by its alias
+ */
+ public function getRelationByAlias($modelName, $alias){ }
+
+
+ /**
+ * Helper method to query records based on a relation definition
+ *
+ * @return \Phalcon\Mvc\Model\Resultset\Simple|Phalcon\Mvc\Model\Resultset\Simple|false
+ */
+ public function getRelationRecords(\Phalcon\Mvc\Model\RelationInterface $relation, $method, \Phalcon\Mvc\ModelInterface $record, $parameters=null){ }
+
+
+ /**
+ * Returns a reusable object from the internal list
+ */
+ public function getReusableRecords($modelName, $key){ }
+
+
+ /**
+ * Stores a reusable record in the internal list
+ */
+ public function setReusableRecords($modelName, $key, $records){ }
+
+
+ /**
+ * Clears the internal reusable list
+ */
+ public function clearReusableObjects(){ }
+
+
+ /**
+ * Gets belongsTo related records from a model
+ */
+ public function getBelongsToRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters=null){ }
+
+
+ /**
+ * Gets hasMany related records from a model
+ */
+ public function getHasManyRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters=null){ }
+
+
+ /**
+ * Gets belongsTo related records from a model
+ */
+ public function getHasOneRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters=null){ }
+
+
+ /**
+ * Gets all the belongsTo relations defined in a model
+ *
+ *
+ * $relations = $modelsManager->getBelongsTo(new Robots());
+ *
+ */
+ public function getBelongsTo(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Gets hasMany relations defined on a model
+ */
+ public function getHasMany(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Gets hasOne relations defined on a model
+ */
+ public function getHasOne(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Gets hasManyToMany relations defined on a model
+ */
+ public function getHasManyToMany(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Gets hasOne relations defined on a model
+ */
+ public function getHasOneAndHasMany(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Query all the relationships defined on a model
+ */
+ public function getRelations($modelName){ }
+
+
+ /**
+ * Query the first relationship defined between two models
+ */
+ public function getRelationsBetween($first, $second){ }
+
+
+ /**
+ * Creates a \Phalcon\Mvc\Model\Query without execute it
+ */
+ public function createQuery($phql){ }
+
+
+ /**
+ * Creates a \Phalcon\Mvc\Model\Query and execute it
+ */
+ public function executeQuery($phql, $placeholders=null, $types=null){ }
+
+
+ /**
+ * Creates a \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function createBuilder($params=null){ }
+
+
+ /**
+ * Returns the lastest query created or executed in the models manager
+ */
+ public function getLastQuery(){ }
+
+
+ /**
+ * Registers shorter aliases for namespaces in PHQL statements
+ */
+ public function registerNamespaceAlias($alias, $namespaceName){ }
+
+
+ /**
+ * Returns a real namespace from its alias
+ */
+ public function getNamespaceAlias($alias){ }
+
+
+ /**
+ * Returns all the registered namespace aliases
+ */
+ public function getNamespaceAliases(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/ManagerInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/ManagerInterface.php
new file mode 100644
index 000000000..19286e7e9
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/ManagerInterface.php
@@ -0,0 +1,121 @@
+
+ * use Phalcon\Mvc\Model\Message as Message;
+ *
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ *
+ * public function beforeSave()
+ * {
+ * if (this->name == 'Peter') {
+ * text = "A robot cannot be named Peter";
+ * field = "name";
+ * type = "InvalidValue";
+ * message = new Message(text, field, type);
+ * this->appendMessage(message);
+ * }
+ * }
+ *
+ * }
+ *
+ *
+ */
+
+ class Message implements \Phalcon\Mvc\Model\MessageInterface {
+
+ protected $_type;
+
+ protected $_message;
+
+ protected $_field;
+
+ protected $_model;
+
+ /**
+ * \Phalcon\Mvc\Model\Message constructor
+ *
+ * @param string message
+ * @param string|array field
+ * @param string type
+ * @param \Phalcon\Mvc\ModelInterface model
+ */
+ public function __construct($message, $field=null, $type=null, $model=null){ }
+
+
+ /**
+ * Sets message type
+ */
+ public function setType($type){ }
+
+
+ /**
+ * Returns message type
+ */
+ public function getType(){ }
+
+
+ /**
+ * Sets verbose message
+ */
+ public function setMessage($message){ }
+
+
+ /**
+ * Returns verbose message
+ */
+ public function getMessage(){ }
+
+
+ /**
+ * Sets field name related to message
+ */
+ public function setField($field){ }
+
+
+ /**
+ * Returns field name related to message
+ */
+ public function getField(){ }
+
+
+ /**
+ * Set the model who generates the message
+ */
+ public function setModel(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the model that produced the message
+ */
+ public function getModel(){ }
+
+
+ /**
+ * Magic __toString method returns verbose message
+ */
+ public function __toString(){ }
+
+
+ /**
+ * Magic __set_state helps to re-build messages variable exporting
+ */
+ public static function __set_state($message){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/MessageInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/MessageInterface.php
new file mode 100644
index 000000000..b4c1e6e70
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/MessageInterface.php
@@ -0,0 +1,34 @@
+Because Phalcon\Mvc\Model requires meta-data like field names, data types, primary keys, etc.
+ * this component collect them and store for further querying by Phalcon\Mvc\Model.
+ * Phalcon\Mvc\Model\MetaData can also use adapters to store temporarily or permanently the meta-data.
+ *
+ * A standard Phalcon\Mvc\Model\MetaData can be used to query model attributes:
+ * + *
+ * $metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
+ * $attributes = $metaData->getAttributes(new Robots());
+ * print_r($attributes);
+ *
+ *
+ */
+
+ abstract class MetaData implements \Phalcon\Di\InjectionAwareInterface {
+
+ const MODELS_ATTRIBUTES = 0;
+
+ const MODELS_PRIMARY_KEY = 1;
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+ const MODELS_NOT_NULL = 3;
+
+ const MODELS_DATA_TYPES = 4;
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+ const MODELS_DATE_AT = 6;
+
+ const MODELS_DATE_IN = 7;
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+ const MODELS_COLUMN_MAP = 0;
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+ protected $_dependencyInjector;
+
+ protected $_strategy;
+
+ protected $_metaData;
+
+ protected $_columnMap;
+
+ /**
+ * Initialize the metadata for certain table
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @param string|null key
+ * @param string|null table
+ * @param string|null schema
+ */
+ final protected function _initialize(\Phalcon\Mvc\ModelInterface $model, $key, $table, $schema){ }
+
+
+ /**
+ * Sets the DependencyInjector container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the DependencyInjector container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Set the meta-data extraction strategy
+ */
+ public function setStrategy(\Phalcon\Mvc\Model\MetaData\StrategyInterface $strategy){ }
+
+
+ /**
+ * Return the strategy to obtain the meta-data
+ */
+ public function getStrategy(){ }
+
+
+ /**
+ * Reads the complete meta-data for certain model
+ *
+ *
+ * print_r($metaData->readMetaData(new Robots());
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @return array
+ */
+ final public function readMetaData(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Reads meta-data for certain model
+ *
+ *
+ * print_r($metaData->readMetaDataIndex(new Robots(), 0);
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @param int index
+ * @return mixed
+ */
+ final public function readMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index){ }
+
+
+ /**
+ * Writes meta-data for certain model using a MODEL_* constant
+ *
+ *
+ * print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @param int index
+ * @param mixed data
+ */
+ final public function writeMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index, $data){ }
+
+
+ /**
+ * Reads the ordered/reversed column map for certain model
+ *
+ *
+ * print_r($metaData->readColumnMap(new Robots()));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @return array
+ */
+ final public function readColumnMap(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Reads column-map information for certain model using a MODEL_* constant
+ *
+ *
+ * print_r($metaData->readColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP));
+ *
+ */
+ final public function readColumnMapIndex(\Phalcon\Mvc\ModelInterface $model, $index){ }
+
+
+ /**
+ * Returns table attributes names (fields)
+ *
+ *
+ * print_r($metaData->getAttributes(new Robots()));
+ *
+ */
+ public function getAttributes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns an array of fields which are part of the primary key
+ *
+ *
+ * print_r($metaData->getPrimaryKeyAttributes(new Robots()));
+ *
+ */
+ public function getPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns an array of fields which are not part of the primary key
+ *
+ *
+ * print_r($metaData->getNonPrimaryKeyAttributes(new Robots()));
+ *
+ */
+ public function getNonPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns an array of not null attributes
+ *
+ *
+ * print_r($metaData->getNotNullAttributes(new Robots()));
+ *
+ */
+ public function getNotNullAttributes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns attributes and their data types
+ *
+ *
+ * print_r($metaData->getDataTypes(new Robots()));
+ *
+ */
+ public function getDataTypes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns attributes which types are numerical
+ *
+ *
+ * print_r($metaData->getDataTypesNumeric(new Robots()));
+ *
+ */
+ public function getDataTypesNumeric(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the name of identity field (if one is present)
+ *
+ *
+ * print_r($metaData->getIdentityField(new Robots()));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @return string
+ */
+ public function getIdentityField(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns attributes and their bind data types
+ *
+ *
+ * print_r($metaData->getBindTypes(new Robots()));
+ *
+ */
+ public function getBindTypes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns attributes that must be ignored from the INSERT SQL generation
+ *
+ *
+ * print_r($metaData->getAutomaticCreateAttributes(new Robots()));
+ *
+ */
+ public function getAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns attributes that must be ignored from the UPDATE SQL generation
+ *
+ *
+ * print_r($metaData->getAutomaticUpdateAttributes(new Robots()));
+ *
+ */
+ public function getAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Set the attributes that must be ignored from the INSERT SQL generation
+ *
+ *
+ * $metaData->setAutomaticCreateAttributes(new Robots(), array('created_at' => true));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @param array attributes
+ */
+ public function setAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes){ }
+
+
+ /**
+ * Set the attributes that must be ignored from the UPDATE SQL generation
+ *
+ *
+ * $metaData->setAutomaticUpdateAttributes(new Robots(), array('modified_at' => true));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @param array attributes
+ */
+ public function setAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes){ }
+
+
+ /**
+ * Returns attributes (which have default values) and their default values
+ *
+ *
+ * print_r($metaData->getDefaultValues(new Robots()));
+ *
+ */
+ public function getDefaultValues(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the column map if any
+ *
+ *
+ * print_r($metaData->getColumnMap(new Robots()));
+ *
+ */
+ public function getColumnMap(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Returns the reverse column map if any
+ *
+ *
+ * print_r($metaData->getReverseColumnMap(new Robots()));
+ *
+ */
+ public function getReverseColumnMap(\Phalcon\Mvc\ModelInterface $model){ }
+
+
+ /**
+ * Check if a model has certain attribute
+ *
+ *
+ * var_dump($metaData->hasAttribute(new Robots(), 'name'));
+ *
+ */
+ public function hasAttribute(\Phalcon\Mvc\ModelInterface $model, $attribute){ }
+
+
+ /**
+ * Checks if the internal meta-data container is empty
+ *
+ *
+ * var_dump($metaData->isEmpty());
+ *
+ */
+ public function isEmpty(){ }
+
+
+ /**
+ * Resets internal meta-data in order to regenerate it
+ *
+ *
+ * $metaData->reset();
+ *
+ */
+ public function reset(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Apc.php b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Apc.php
new file mode 100644
index 000000000..48a12f832
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Apc.php
@@ -0,0 +1,78 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Apc(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+
+ class Apc extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\Model\MetaDataInterface {
+
+ const MODELS_ATTRIBUTES = 0;
+
+ const MODELS_PRIMARY_KEY = 1;
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+ const MODELS_NOT_NULL = 3;
+
+ const MODELS_DATA_TYPES = 4;
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+ const MODELS_DATE_AT = 6;
+
+ const MODELS_DATE_IN = 7;
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+ const MODELS_COLUMN_MAP = 0;
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+ protected $_prefix;
+
+ protected $_ttl;
+
+ /**
+ * \Phalcon\Mvc\Model\MetaData\Apc constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Reads meta-data from APC
+ */
+ public function read($key){ }
+
+
+ /**
+ * Writes the meta-data to APC
+ */
+ public function write($key, $data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Files.php b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Files.php
new file mode 100644
index 000000000..18b1e7e72
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Files.php
@@ -0,0 +1,77 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Files(array(
+ * 'metaDataDir' => 'app/cache/metadata/'
+ * ));
+ *
+ */
+
+ class Files extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\Model\MetaDataInterface {
+
+ const MODELS_ATTRIBUTES = 0;
+
+ const MODELS_PRIMARY_KEY = 1;
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+ const MODELS_NOT_NULL = 3;
+
+ const MODELS_DATA_TYPES = 4;
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+ const MODELS_DATE_AT = 6;
+
+ const MODELS_DATE_IN = 7;
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+ const MODELS_COLUMN_MAP = 0;
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+ protected $_metaDataDir;
+
+ /**
+ * \Phalcon\Mvc\Model\MetaData\Files constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Reads meta-data from files
+ *
+ * @param string key
+ * @return mixed
+ */
+ public function read($key){ }
+
+
+ /**
+ * Writes the meta-data to files
+ *
+ * @param string key
+ * @param array data
+ */
+ public function write($key, $data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Memory.php b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Memory.php
new file mode 100644
index 000000000..b46172d32
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Memory.php
@@ -0,0 +1,70 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Session(array(
+ * 'prefix' => 'my-app-id'
+ * ));
+ *
+ */
+
+ class Session extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\Model\MetaDataInterface {
+
+ const MODELS_ATTRIBUTES = 0;
+
+ const MODELS_PRIMARY_KEY = 1;
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+ const MODELS_NOT_NULL = 3;
+
+ const MODELS_DATA_TYPES = 4;
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+ const MODELS_DATE_AT = 6;
+
+ const MODELS_DATE_IN = 7;
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+ const MODELS_COLUMN_MAP = 0;
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+ protected $_prefix;
+
+ /**
+ * \Phalcon\Mvc\Model\MetaData\Session constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Reads meta-data from $_SESSION
+ *
+ * @param string key
+ * @return array
+ */
+ public function read($key){ }
+
+
+ /**
+ * Writes the meta-data to $_SESSION
+ *
+ * @param string key
+ * @param array data
+ */
+ public function write($key, $data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Strategy/Annotations.php b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Strategy/Annotations.php
new file mode 100644
index 000000000..8b9c6e2c6
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/MetaData/Strategy/Annotations.php
@@ -0,0 +1,19 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Xcache(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+
+ class Xcache extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\Model\MetaDataInterface {
+
+ const MODELS_ATTRIBUTES = 0;
+
+ const MODELS_PRIMARY_KEY = 1;
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+ const MODELS_NOT_NULL = 3;
+
+ const MODELS_DATA_TYPES = 4;
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+ const MODELS_DATE_AT = 6;
+
+ const MODELS_DATE_IN = 7;
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+ const MODELS_COLUMN_MAP = 0;
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+ protected $_prefix;
+
+ protected $_ttl;
+
+ /**
+ * \Phalcon\Mvc\Model\MetaData\Xcache constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Reads metadata from XCache
+ *
+ * @param string key
+ * @return array
+ */
+ public function read($key){ }
+
+
+ /**
+ * Writes the metadata to XCache
+ *
+ * @param string key
+ * @param array data
+ */
+ public function write($key, $data){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/MetaDataInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/MetaDataInterface.php
new file mode 100644
index 000000000..67cc283d2
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/MetaDataInterface.php
@@ -0,0 +1,88 @@
+
+ *
+ * $phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
+ * WHERE b.name = :name: ORDER BY c.name";
+ *
+ * $result = manager->executeQuery($phql, array(
+ * "name": "Lamborghini"
+ * ));
+ *
+ * foreach ($result as $row) {
+ * echo "Name: ", $row->cars->name, "\n";
+ * echo "Price: ", $row->cars->price, "\n";
+ * echo "Taxes: ", $row->taxes, "\n";
+ * }
+ *
+ *
+ */
+
+ class Query implements \Phalcon\Mvc\Model\QueryInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ const TYPE_SELECT = 309;
+
+ const TYPE_INSERT = 306;
+
+ const TYPE_UPDATE = 300;
+
+ const TYPE_DELETE = 303;
+
+ protected $_dependencyInjector;
+
+ protected $_manager;
+
+ protected $_metaData;
+
+ protected $_type;
+
+ protected $_phql;
+
+ protected $_ast;
+
+ protected $_intermediate;
+
+ protected $_models;
+
+ protected $_sqlAliases;
+
+ protected $_sqlAliasesModels;
+
+ protected $_sqlModelsAliases;
+
+ protected $_sqlAliasesModelsInstances;
+
+ protected $_sqlColumnAliases;
+
+ protected $_modelsInstances;
+
+ protected $_cache;
+
+ protected $_cacheOptions;
+
+ protected $_uniqueRow;
+
+ protected $_bindParams;
+
+ protected $_bindTypes;
+
+ protected static $_irPhqlCache;
+
+ /**
+ * \Phalcon\Mvc\Model\Query constructor
+ *
+ * @param string phql
+ * @param \Phalcon\DiInterface dependencyInjector
+ */
+ public function __construct($phql=null, \Phalcon\DiInterface $dependencyInjector=null){ }
+
+
+ /**
+ * Sets the dependency injection container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the dependency injection container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Tells to the query if only the first row in the resultset must be returned
+ */
+ public function setUniqueRow($uniqueRow){ }
+
+
+ /**
+ * Check if the query is programmed to get only the first row in the resultset
+ */
+ public function getUniqueRow(){ }
+
+
+ /**
+ * Replaces the model's name to its source name in a qualifed-name expression
+ */
+ final protected function _getQualified($expr){ }
+
+
+ /**
+ * Resolves a expression in a single call argument
+ */
+ final protected function _getCallArgument($argument){ }
+
+
+ /**
+ * Resolves a expression in a single call argument
+ */
+ final protected function _getFunctionCall($expr){ }
+
+
+ /**
+ * Resolves an expression from its intermediate code into a string
+ *
+ * @param array expr
+ * @param boolean quoting
+ * @return string
+ */
+ final protected function _getExpression($expr, $quoting=null){ }
+
+
+ /**
+ * Resolves a column from its intermediate representation into an array used to determine
+ * if the resulset produced is simple or complex
+ *
+ * @param array column
+ * @return array
+ */
+ final protected function _getSelectColumn($column){ }
+
+
+ /**
+ * Resolves a table in a SELECT statement checking if the model exists
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface manager
+ * @param array qualifiedName
+ * @return string
+ */
+ final protected function _getTable(\Phalcon\Mvc\Model\ManagerInterface $manager, $qualifiedName){ }
+
+
+ /**
+ * Resolves a JOIN clause checking if the associated models exist
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface manager
+ * @param array join
+ * @return array
+ */
+ final protected function _getJoin(\Phalcon\Mvc\Model\ManagerInterface $manager, $join){ }
+
+
+ /**
+ * Resolves a JOIN type
+ *
+ * @param array join
+ * @return string
+ */
+ final protected function _getJoinType($join){ }
+
+
+ /**
+ * Resolves joins involving has-one/belongs-to/has-many relations
+ *
+ * @param string joinType
+ * @param string joinSource
+ * @param string modelAlias
+ * @param string joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface relation
+ * @return array
+ */
+ final protected function _getSingleJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation){ }
+
+
+ /**
+ * Resolves joins involving many-to-many relations
+ *
+ * @param string joinType
+ * @param string joinSource
+ * @param string modelAlias
+ * @param string joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface relation
+ * @return array
+ */
+ final protected function _getMultiJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation){ }
+
+
+ /**
+ * Processes the JOINs in the query returning an internal representation for the database dialect
+ *
+ * @param array select
+ * @return array
+ */
+ final protected function _getJoins($select){ }
+
+
+ /**
+ * Returns a processed order clause for a SELECT statement
+ *
+ * @param array|string $order
+ * @return array
+ */
+ final protected function _getOrderClause($order){ }
+
+
+ /**
+ * Returns a processed group clause for a SELECT statement
+ *
+ * @param array $group
+ * @return array
+ */
+ final protected function _getGroupClause($group){ }
+
+
+ /**
+ * Returns a processed limit clause for a SELECT statement
+ *
+ * @param array $limit
+ * @return array
+ */
+ final protected function _getLimitClause($limitClause){ }
+
+
+ /**
+ * Analyzes a SELECT intermediate code and produces an array to be executed later
+ */
+ final protected function _prepareSelect($ast=null, $merge=null){ }
+
+
+ /**
+ * Analyzes an INSERT intermediate code and produces an array to be executed later
+ */
+ final protected function _prepareInsert(){ }
+
+
+ /**
+ * Analyzes an UPDATE intermediate code and produces an array to be executed later
+ */
+ final protected function _prepareUpdate(){ }
+
+
+ /**
+ * Analyzes a DELETE intermediate code and produces an array to be executed later
+ */
+ final protected function _prepareDelete(){ }
+
+
+ /**
+ * Parses the intermediate code produced by \Phalcon\Mvc\Model\Query\Lang generating another
+ * intermediate representation that could be executed by \Phalcon\Mvc\Model\Query
+ */
+ public function parse(){ }
+
+
+ /**
+ * Returns the current cache backend instance
+ */
+ public function getCache(){ }
+
+
+ /**
+ * Executes the SELECT intermediate representation producing a \Phalcon\Mvc\Model\Resultset
+ *
+ * @param array intermediate
+ * @param array bindParams
+ * @param array bindTypes
+ * @throws \Phalcon\Mvc\Model\Exception
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ final protected function _executeSelect($intermediate, $bindParams, $bindTypes){ }
+
+
+ /**
+ * Executes the INSERT intermediate representation producing a \Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array intermediate
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ final protected function _executeInsert($intermediate, $bindParams, $bindTypes){ }
+
+
+ /**
+ * Executes the UPDATE intermediate representation producing a \Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array intermediate
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ final protected function _executeUpdate($intermediate, $bindParams, $bindTypes){ }
+
+
+ /**
+ * Executes the DELETE intermediate representation producing a \Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array intermediate
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ final protected function _executeDelete($intermediate, $bindParams, $bindTypes){ }
+
+
+ /**
+ * Query the records on which the UPDATE/DELETE operation well be done
+ *
+ * @param \Phalcon\Mvc\ModelInterface model
+ * @param array intermediate
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ final protected function _getRelatedRecords(\Phalcon\Mvc\ModelInterface $model, $intermediate, $bindParams, $bindTypes){ }
+
+
+ /**
+ * Executes a parsed PHQL statement
+ *
+ * @param array bindParams
+ * @param array bindTypes
+ * @return mixed
+ */
+ public function execute($bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Executes the query returning the first result
+ *
+ * @param array bindParams
+ * @param array bindTypes
+ * @return Ṕhalcon\Mvc\ModelInterface
+ */
+ public function getSingleResult($bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Sets the type of PHQL statement to be executed
+ */
+ public function setType($type){ }
+
+
+ /**
+ * Gets the type of PHQL statement executed
+ */
+ public function getType(){ }
+
+
+ /**
+ * Set default bind parameters
+ */
+ public function setBindParams($bindParams){ }
+
+
+ /**
+ * Returns default bind params
+ *
+ * @return array
+ */
+ public function getBindParams(){ }
+
+
+ /**
+ * Set default bind parameters
+ */
+ public function setBindTypes($bindTypes){ }
+
+
+ /**
+ * Returns default bind types
+ *
+ * @return array
+ */
+ public function getBindTypes(){ }
+
+
+ /**
+ * Allows to set the IR to be executed
+ */
+ public function setIntermediate($intermediate){ }
+
+
+ /**
+ * Returns the intermediate representation of the PHQL statement
+ *
+ * @return array
+ */
+ public function getIntermediate(){ }
+
+
+ /**
+ * Sets the cache parameters of the query
+ *
+ * @param array cacheOptions
+ * @return \Phalcon\Mvc\Model\Query
+ */
+ public function cache($cacheOptions){ }
+
+
+ /**
+ * Returns the current cache options
+ *
+ * @param array
+ */
+ public function getCacheOptions(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Query/Builder.php b/ide/2.0.2/Phalcon/Mvc/Model/Query/Builder.php
new file mode 100644
index 000000000..8d3825670
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Query/Builder.php
@@ -0,0 +1,446 @@
+
+ * $params = array(
+ * 'models' => array('Users'),
+ * 'columns' => array('id', 'name', 'status'),
+ * 'conditions' => array(
+ * array(
+ * "created > :min: AND created < :max:",
+ * array("min" => '2013-01-01', 'max' => '2014-01-01'),
+ * array("min" => PDO::PARAM_STR, 'max' => PDO::PARAM_STR),
+ * ),
+ * ),
+ * // or 'conditions' => "created > '2013-01-01' AND created < '2014-01-01'",
+ * 'group' => array('id', 'name'),
+ * 'having' => "name = 'Kamil'",
+ * 'order' => array('name', 'id'),
+ * 'limit' => 20,
+ * 'offset' => 20,
+ * // or 'limit' => array(20, 20),
+ *);
+ *$queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);
+ *
+ */
+
+ class Builder implements \Phalcon\Mvc\Model\Query\BuilderInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_columns;
+
+ protected $_models;
+
+ protected $_joins;
+
+ protected $_conditions;
+
+ protected $_group;
+
+ protected $_having;
+
+ protected $_order;
+
+ protected $_limit;
+
+ protected $_offset;
+
+ protected $_forUpdate;
+
+ protected $_sharedLock;
+
+ protected $_bindParams;
+
+ protected $_bindTypes;
+
+ protected $_distinct;
+
+ protected $_hiddenParamNumber;
+
+ /**
+ * \Phalcon\Mvc\Model\Query\Builder constructor
+ *
+ * @param array params
+ * @param \Phalcon\DiInterface dependencyInjector
+ */
+ public function __construct($params=null, \Phalcon\DiInterface $dependencyInjector=null){ }
+
+
+ /**
+ * Sets the DependencyInjector container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the DependencyInjector container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param bool|null distinct
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function distinct($distinct){ }
+
+
+ /**
+ * Returns SELECT DISTINCT / SELECT ALL flag
+ */
+ public function getDistinct(){ }
+
+
+ /**
+ * Sets the columns to be queried
+ *
+ *
+ * $builder->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array columns
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function columns($columns){ }
+
+
+ /**
+ * Return the columns to be queried
+ *
+ * @return string|array
+ */
+ public function getColumns(){ }
+
+
+ /**
+ * Sets the models who makes part of the query
+ *
+ *
+ * $builder->from('Robots');
+ * $builder->from(array('Robots', 'RobotsParts'));
+ *
+ *
+ * @param string|array models
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function from($models){ }
+
+
+ /**
+ * Add a model to take part of the query
+ *
+ *
+ * $builder->addFrom('Robots', 'r');
+ *
+ *
+ * @param string model
+ * @param string alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function addFrom($model, $alias=null){ }
+
+
+ /**
+ * Return the models who makes part of the query
+ *
+ * @return string|array
+ */
+ public function getFrom(){ }
+
+
+ /**
+ * Adds a INNER join to the query
+ *
+ *
+ * $builder->join('Robots');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'INNER');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @param string type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function join($model, $conditions=null, $alias=null, $type=null){ }
+
+
+ /**
+ * Adds a INNER join to the query
+ *
+ *
+ * $builder->innerJoin('Robots');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @param string type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function innerJoin($model, $conditions=null, $alias=null){ }
+
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ *
+ * $builder->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function leftJoin($model, $conditions=null, $alias=null){ }
+
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ *
+ * $builder->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string model
+ * @param string conditions
+ * @param string alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function rightJoin($model, $conditions=null, $alias=null){ }
+
+
+ /**
+ * Sets the query conditions
+ *
+ *
+ * $builder->where(100);
+ * $builder->where('name = "Peter"');
+ * $builder->where('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param mixed conditions
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function where($conditions, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Appends a condition to the current conditions using a AND operator
+ *
+ *
+ * $builder->andWhere('name = "Peter"');
+ * $builder->andWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string conditions
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function andWhere($conditions, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Appends a condition to the current conditions using a OR operator
+ *
+ *
+ * $builder->orWhere('name = "Peter"');
+ * $builder->orWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string conditions
+ * @param array bindParams
+ * @param array bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orWhere($conditions, $bindParams=null, $bindTypes=null){ }
+
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ *
+ * $builder->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string expr
+ * @param mixed minimum
+ * @param mixed maximum
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function betweenWhere($expr, $minimum, $maximum){ }
+
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ *
+ * $builder->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string expr
+ * @param mixed minimum
+ * @param mixed maximum
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum){ }
+
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ *
+ * $builder->inWhere('id', [1, 2, 3]);
+ *
+ */
+ public function inWhere($expr, $values){ }
+
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ *
+ * $builder->notInWhere('id', [1, 2, 3]);
+ *
+ */
+ public function notInWhere($expr, $values){ }
+
+
+ /**
+ * Return the conditions for the query
+ *
+ * @return string|array
+ */
+ public function getWhere(){ }
+
+
+ /**
+ * Sets a ORDER BY condition clause
+ *
+ *
+ * $builder->orderBy('Robots.name');
+ * $builder->orderBy(array('1', 'Robots.name'));
+ *
+ *
+ * @param string|array orderBy
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orderBy($orderBy){ }
+
+
+ /**
+ * Returns the set ORDER BY clause
+ *
+ * @return string|array
+ */
+ public function getOrderBy(){ }
+
+
+ /**
+ * Sets a HAVING condition clause. You need to escape PHQL reserved words using [ and ] delimiters
+ *
+ *
+ * $builder->having('SUM(Robots.price) > 0');
+ *
+ */
+ public function having($having){ }
+
+
+ /**
+ * Return the current having clause
+ *
+ * @return string|array
+ */
+ public function getHaving(){ }
+
+
+ /**
+ * Sets a LIMIT clause, optionally a offset clause
+ *
+ *
+ * $builder->limit(100);
+ * $builder->limit(100, 20);
+ *
+ */
+ public function limit($limit=null, $offset=null){ }
+
+
+ /**
+ * Returns the current LIMIT clause
+ *
+ * @return string|array
+ */
+ public function getLimit(){ }
+
+
+ /**
+ * Sets an OFFSET clause
+ *
+ *
+ * $builder->offset(30);
+ *
+ */
+ public function offset($offset){ }
+
+
+ /**
+ * Returns the current OFFSET clause
+ *
+ * @return string|array
+ */
+ public function getOffset(){ }
+
+
+ /**
+ * Sets a GROUP BY clause
+ *
+ *
+ * $builder->groupBy(array('Robots.name'));
+ *
+ *
+ * @param string|array group
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function groupBy($group){ }
+
+
+ /**
+ * Returns the GROUP BY clause
+ *
+ * @return string
+ */
+ public function getGroupBy(){ }
+
+
+ /**
+ * Returns a PHQL statement built based on the builder parameters
+ *
+ * @return string
+ */
+ public function getPhql(){ }
+
+
+ /**
+ * Returns the query built
+ */
+ public function getQuery(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Query/BuilderInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/Query/BuilderInterface.php
new file mode 100644
index 000000000..a54334b5e
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Query/BuilderInterface.php
@@ -0,0 +1,91 @@
+
+ * $intermediate = Phalcon\Mvc\Model\Query\Lang::parsePHQL("SELECT r.* FROM Robots r LIMIT 10");
+ *
+ */
+
+ abstract class Lang {
+
+ /**
+ * Parses a PHQL statement returning an intermediate representation (IR)
+ *
+ * @param string phql
+ * @return string
+ */
+ public static function parsePHQL($phql){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Query/Status.php b/ide/2.0.2/Phalcon/Mvc/Model/Query/Status.php
new file mode 100644
index 000000000..22579e9d0
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Query/Status.php
@@ -0,0 +1,61 @@
+
+ *$phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";
+ *$status = $app->modelsManager->executeQuery($phql, array(
+ * 'id' => 100,
+ * 'name' => 'Astroy Boy',
+ * 'type' => 'mechanical',
+ * 'year' => 1959
+ *));
+ *
+ *\//Check if the update was successful
+ *if ($status->success() == true) {
+ * echo 'OK';
+ *}
+ *
+ */
+
+ class Status implements \Phalcon\Mvc\Model\Query\StatusInterface {
+
+ protected $_success;
+
+ protected $_model;
+
+ /**
+ * \Phalcon\Mvc\Model\Query\Status
+ */
+ public function __construct($success, \Phalcon\Mvc\ModelInterface $model=null){ }
+
+
+ /**
+ * Returns the model that executed the action
+ */
+ public function getModel(){ }
+
+
+ /**
+ * Returns the messages produced because of a failed operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface[]
+ */
+ public function getMessages(){ }
+
+
+ /**
+ * Allows to check if the executed operation was successful
+ */
+ public function success(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Query/StatusInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/Query/StatusInterface.php
new file mode 100644
index 000000000..0c0a9464b
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Query/StatusInterface.php
@@ -0,0 +1,19 @@
+
+ *
+ * //Using a standard foreach
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ *
+ * //Using a while
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * $robots->rewind();
+ * while ($robots->valid()) {
+ * $robot = $robots->current();
+ * echo $robot->name, "\n";
+ * $robots->next();
+ * }
+ *
+ */
+
+ abstract class Resultset implements \Phalcon\Mvc\Model\ResultsetInterface, \Iterator, \Traversable, \SeekableIterator, \Countable, \ArrayAccess, \Serializable {
+
+ const TYPE_RESULT_FULL = 0;
+
+ const TYPE_RESULT_PARTIAL = 1;
+
+ const HYDRATE_RECORDS = 0;
+
+ const HYDRATE_OBJECTS = 2;
+
+ const HYDRATE_ARRAYS = 1;
+
+ protected $_result;
+
+ protected $_cache;
+
+ protected $_isFresh;
+
+ protected $_pointer;
+
+ protected $_count;
+
+ protected $_activeRow;
+
+ protected $_rows;
+
+ protected $_row;
+
+ protected $_errorMessages;
+
+ protected $_hydrateMode;
+
+ /**
+ * \Phalcon\Mvc\Model\Resultset constructor
+ *
+ * @param array columnTypes
+ * @param \Phalcon\Db\ResultInterface|false result
+ * @param \Phalcon\Cache\BackendInterface cache
+ */
+ public function __construct($result, \Phalcon\Cache\BackendInterface $cache=null){ }
+
+
+ /**
+ * Moves cursor to next row in the resultset
+ */
+ public function next(){ }
+
+
+ /**
+ * Check whether internal resource has rows to fetch
+ */
+ public function valid(){ }
+
+
+ /**
+ * Gets pointer number of active row in the resultset
+ */
+ public function key(){ }
+
+
+ /**
+ * Rewinds resultset to its beginning
+ */
+ final public function rewind(){ }
+
+
+ /**
+ * Changes internal pointer to a specific position in the resultset
+ * Set new position if required and set this->_row
+ */
+ final public function seek($position){ }
+
+
+ /**
+ * Counts how many rows are in the resultset
+ */
+ final public function count(){ }
+
+
+ /**
+ * Checks whether offset exists in the resultset
+ */
+ public function offsetExists($index){ }
+
+
+ /**
+ * Gets row in a specific position of the resultset
+ */
+ public function offsetGet($index){ }
+
+
+ /**
+ * Resulsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int index
+ * @param \Phalcon\Mvc\ModelInterface value
+ */
+ public function offsetSet($index, $value){ }
+
+
+ /**
+ * Resulsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ */
+ public function offsetUnset($offset){ }
+
+
+ /**
+ * Returns the internal type of data retrieval that the resultset is using
+ */
+ public function getType(){ }
+
+
+ /**
+ * Get first row in the resultset
+ */
+ public function getFirst(){ }
+
+
+ /**
+ * Get last row in the resultset
+ */
+ public function getLast(){ }
+
+
+ /**
+ * Set if the resultset is fresh or an old one cached
+ */
+ public function setIsFresh($isFresh){ }
+
+
+ /**
+ * Tell if the resultset if fresh or an old one cached
+ */
+ public function isFresh(){ }
+
+
+ /**
+ * Sets the hydration mode in the resultset
+ */
+ public function setHydrateMode($hydrateMode){ }
+
+
+ /**
+ * Returns the current hydration mode
+ */
+ public function getHydrateMode(){ }
+
+
+ /**
+ * Returns the associated cache for the resultset
+ */
+ public function getCache(){ }
+
+
+ /**
+ * Returns the error messages produced by a batch operation
+ */
+ public function getMessages(){ }
+
+
+ /**
+ * Updates every record in the resultset
+ *
+ * @param array data
+ * @param Closure conditionCallback
+ * @return boolean
+ */
+ public function update($data, \Closure $conditionCallback=null){ }
+
+
+ /**
+ * Deletes every record in the resultset
+ */
+ public function delete(\Closure $conditionCallback=null){ }
+
+
+ /**
+ * Filters a resultset returning only those the developer requires
+ *
+ *
+ * $filtered = $robots->filter(function($robot){
+ * if ($robot->id < 3) {
+ * return $robot;
+ * }
+ * });
+ *
+ *
+ * @param callback filter
+ * @return \Phalcon\Mvc\Model[]
+ */
+ public function filter($filter){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Resultset/Complex.php b/ide/2.0.2/Phalcon/Mvc/Model/Resultset/Complex.php
new file mode 100644
index 000000000..e2a2b8d3c
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Resultset/Complex.php
@@ -0,0 +1,65 @@
+x or array[x].
+ */
+
+ class Row implements \ArrayAccess, \Phalcon\Mvc\Model\ResultInterface {
+
+ /**
+ * Set the current object's state
+ */
+ public function setDirtyState($dirtyState){ }
+
+
+ /**
+ * Checks whether offset exists in the row
+ *
+ * @param string|int $index
+ * @return boolean
+ */
+ public function offsetExists($index){ }
+
+
+ /**
+ * Gets a record in a specific position of the row
+ *
+ * @param string|int index
+ * @return string|Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index){ }
+
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int index
+ * @param \Phalcon\Mvc\ModelInterface value
+ */
+ public function offsetSet($index, $value){ }
+
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int offset
+ */
+ public function offsetUnset($offset){ }
+
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Transaction.php b/ide/2.0.2/Phalcon/Mvc/Model/Transaction.php
new file mode 100644
index 000000000..43e5644cd
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Transaction.php
@@ -0,0 +1,139 @@
+
+ *try {
+ *
+ * $manager = new \Phalcon\Mvc\Model\Transaction\Manager();
+ *
+ * $transaction = $manager->get();
+ *
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ *
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Can't save robot part");
+ * }
+ *
+ * $transaction->commit();
+ *
+ *} catch(Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ *}
+ *
+ *
+ */
+
+ class Transaction implements \Phalcon\Mvc\Model\TransactionInterface {
+
+ protected $_connection;
+
+ protected $_activeTransaction;
+
+ protected $_isNewTransaction;
+
+ protected $_rollbackOnAbort;
+
+ protected $_manager;
+
+ protected $_messages;
+
+ protected $_rollbackRecord;
+
+ /**
+ * \Phalcon\Mvc\Model\Transaction constructor
+ *
+ * @param \Phalcon\DiInterface $ependencyInjector
+ * @param boolean autoBegin
+ * @param string service
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector, $autoBegin=null, $service=null){ }
+
+
+ /**
+ * Sets transaction manager related to the transaction
+ */
+ public function setTransactionManager(\Phalcon\Mvc\Model\Transaction\ManagerInterface $manager){ }
+
+
+ /**
+ * Starts the transaction
+ */
+ public function begin(){ }
+
+
+ /**
+ * Commits the transaction
+ */
+ public function commit(){ }
+
+
+ /**
+ * Rollbacks the transaction
+ *
+ * @param string rollbackMessage
+ * @param \Phalcon\Mvc\ModelInterface rollbackRecord
+ * @return boolean
+ */
+ public function rollback($rollbackMessage=null, $rollbackRecord=null){ }
+
+
+ /**
+ * Returns the connection related to transaction
+ */
+ public function getConnection(){ }
+
+
+ /**
+ * Sets if is a reused transaction or new once
+ */
+ public function setIsNewTransaction($isNew){ }
+
+
+ /**
+ * Sets flag to rollback on abort the HTTP connection
+ */
+ public function setRollbackOnAbort($rollbackOnAbort){ }
+
+
+ /**
+ * Checks whether transaction is managed by a transaction manager
+ */
+ public function isManaged(){ }
+
+
+ /**
+ * Returns validations messages from last save try
+ */
+ public function getMessages(){ }
+
+
+ /**
+ * Checks whether internal connection is under an active transaction
+ */
+ public function isValid(){ }
+
+
+ /**
+ * Sets object which generates rollback action
+ */
+ public function setRollbackedRecord(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Transaction/Exception.php b/ide/2.0.2/Phalcon/Mvc/Model/Transaction/Exception.php
new file mode 100644
index 000000000..1205b4833
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Transaction/Exception.php
@@ -0,0 +1,7 @@
+
+ *try {
+ *
+ * use Phalcon\Mvc\Model\Transaction\Manager as TransactionManager;
+ *
+ * $transactionManager = new TransactionManager();
+ *
+ * $transaction = $transactionManager->get();
+ *
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if($robot->save()==false){
+ * $transaction->rollback("Can't save robot");
+ * }
+ *
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if($robotPart->save()==false){
+ * $transaction->rollback("Can't save robot part");
+ * }
+ *
+ * $transaction->commit();
+ *
+ *} catch (Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ *}
+ *
+ *
+ *
+ */
+
+ class Manager implements \Phalcon\Mvc\Model\Transaction\ManagerInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_initialized;
+
+ protected $_rollbackPendent;
+
+ protected $_number;
+
+ protected $_service;
+
+ protected $_transactions;
+
+ /**
+ * \Phalcon\Mvc\Model\Transaction\Manager constructor
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector=null){ }
+
+
+ /**
+ * Sets the dependency injection container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the dependency injection container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets the database service used to run the isolated transactions
+ */
+ public function setDbService($service){ }
+
+
+ /**
+ * Returns the database service used to isolate the transaction
+ *
+ * @return string
+ */
+ public function getDbService(){ }
+
+
+ /**
+ * Set if the transaction manager must register a shutdown function to clean up pendent transactions
+ */
+ public function setRollbackPendent($rollbackPendent){ }
+
+
+ /**
+ * Check if the transaction manager is registering a shutdown function to clean up pendent transactions
+ */
+ public function getRollbackPendent(){ }
+
+
+ /**
+ * Checks whether the manager has an active transaction
+ */
+ public function has(){ }
+
+
+ /**
+ * Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
+ * This method registers a shutdown function to rollback active connections
+ */
+ public function get($autoBegin=null){ }
+
+
+ /**
+ * Create/Returns a new transaction or an existing one
+ */
+ public function getOrCreateTransaction($autoBegin=null){ }
+
+
+ /**
+ * Rollbacks active transactions within the manager
+ */
+ public function rollbackPendent(){ }
+
+
+ /**
+ * Commmits active transactions within the manager
+ */
+ public function commit(){ }
+
+
+ /**
+ * Rollbacks active transactions within the manager
+ * Collect will remove the transaction from the manager
+ *
+ * @param boolean collect
+ */
+ public function rollback($collect=null){ }
+
+
+ /**
+ * Notifies the manager about a rollbacked transaction
+ */
+ public function notifyRollback(\Phalcon\Mvc\Model\TransactionInterface $transaction){ }
+
+
+ /**
+ * Notifies the manager about a commited transaction
+ */
+ public function notifyCommit(\Phalcon\Mvc\Model\TransactionInterface $transaction){ }
+
+
+ /**
+ * Removes transactions from the TransactionManager
+ */
+ protected function _collectTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction){ }
+
+
+ /**
+ * Remove all the transactions from the manager
+ */
+ public function collectTransactions(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Transaction/ManagerInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/Transaction/ManagerInterface.php
new file mode 100644
index 000000000..fea608b4e
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Transaction/ManagerInterface.php
@@ -0,0 +1,34 @@
+
+ * use Phalcon\Mvc\Model\Validator\Email as EmailValidator;
+ *
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ *
+ * public function validation()
+ * {
+ * $this->validate(new EmailValidator(array(
+ * 'field' => 'electronic_mail'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ * }
+ *
+ */
+
+ class Email extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/Exclusionin.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Exclusionin.php
new file mode 100644
index 000000000..d3c53cd6a
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Exclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionInValidator;
+ *
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ *
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionInValidator(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ * }
+ *
+ */
+
+ class Exclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/Inclusionin.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Inclusionin.php
new file mode 100644
index 000000000..b9c92ae1f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Inclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\InclusionIn as InclusionInValidator;
+ *
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ *
+ * public function validation()
+ * {
+ * $this->validate(new InclusionInValidator(array(
+ * "field" => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ * }
+ *
+ */
+
+ class Inclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/Numericality.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Numericality.php
new file mode 100644
index 000000000..888767f11
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Numericality.php
@@ -0,0 +1,38 @@
+
+ *use Phalcon\Mvc\Model\Validator\Numericality as NumericalityValidator;
+ *
+ *class Products extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new NumericalityValidator(array(
+ * "field" => 'price'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+
+ class Numericality extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/PresenceOf.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/PresenceOf.php
new file mode 100644
index 000000000..48fccff27
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/PresenceOf.php
@@ -0,0 +1,39 @@
+
+ *use Phalcon\Mvc\Model\Validator\PresenceOf;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new PresenceOf(array(
+ * "field" => 'name',
+ * "message" => 'The name is required'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+
+ class PresenceOf extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/Regex.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Regex.php
new file mode 100644
index 000000000..bd84b2881
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Regex.php
@@ -0,0 +1,39 @@
+
+ *use Phalcon\Mvc\Model\Validator\Regex as RegexValidator;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new RegexValidator(array(
+ * "field" => 'created_at',
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])/'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+
+ class Regex extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/StringLength.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/StringLength.php
new file mode 100644
index 000000000..b2c4595be
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/StringLength.php
@@ -0,0 +1,42 @@
+
+ *use Phalcon\Mvc\Model\Validator\StringLength as StringLengthValidator;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new StringLengthValidator(array(
+ * "field" => 'name_last',
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+
+ class StringLength extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/Uniqueness.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Uniqueness.php
new file mode 100644
index 000000000..f597f432e
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Uniqueness.php
@@ -0,0 +1,39 @@
+
+ *use Phalcon\Mvc\Model\Validator\Uniqueness as Uniqueness;
+ *
+ *class Subscriptors extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new Uniqueness(array(
+ * "field" => 'email'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+
+ class Uniqueness extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/Validator/Url.php b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Url.php
new file mode 100644
index 000000000..ab6fbdf9d
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/Validator/Url.php
@@ -0,0 +1,38 @@
+
+ *use Phalcon\Mvc\Model\Validator\Url as UrlValidator;
+ *
+ *class Posts extends \Phalcon\Mvc\Model
+ *{
+ *
+ * public function validation()
+ * {
+ * $this->validate(new UrlValidator(array(
+ * 'field' => 'source_url'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ *
+ *}
+ *
+ */
+
+ class Url extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface {
+
+ /**
+ * Executes the validator
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Model/ValidatorInterface.php b/ide/2.0.2/Phalcon/Mvc/Model/ValidatorInterface.php
new file mode 100644
index 000000000..34327b0c4
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Model/ValidatorInterface.php
@@ -0,0 +1,13 @@
+Phalcon\Mvc\Router is the standard framework router. Routing is the
+ * process of taking a URI endpoint (that part of the URI which comes after the base URL) and
+ * decomposing it into parameters to determine which module, controller, and
+ * action of that controller should receive the request
+ *
+ *
+ *
+ * $router = new Router();
+ *
+ * $router->add(
+ * "/documentation/{chapter}/{name}.{type:[a-z]+}",
+ * array(
+ * "controller" => "documentation",
+ * "action" => "show"
+ * )
+ * );
+ *
+ * $router->handle();
+ *
+ * echo $router->getControllerName();
+ *
+ */
+
+ class Router implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\RouterInterface {
+
+ const URI_SOURCE_GET_URL = 0;
+
+ const URI_SOURCE_SERVER_REQUEST_URI = 1;
+
+ protected $_dependencyInjector;
+
+ protected $_uriSource;
+
+ protected $_namespace;
+
+ protected $_module;
+
+ protected $_controller;
+
+ protected $_action;
+
+ protected $_params;
+
+ protected $_routes;
+
+ protected $_matchedRoute;
+
+ protected $_matches;
+
+ protected $_wasMatched;
+
+ protected $_defaultNamespace;
+
+ protected $_defaultModule;
+
+ protected $_defaultController;
+
+ protected $_defaultAction;
+
+ protected $_defaultParams;
+
+ protected $_removeExtraSlashes;
+
+ protected $_notFoundPaths;
+
+ /**
+ * \Phalcon\Mvc\Router constructor
+ */
+ public function __construct($defaultRoutes=null){ }
+
+
+ /**
+ * Sets the dependency injector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the internal dependency injector
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Get rewrite info. This info is read from $_GET['_url']. This returns '/' if the rewrite information cannot be read
+ */
+ public function getRewriteUri(){ }
+
+
+ /**
+ * Sets the URI source. One of the URI_SOURCE_* constants
+ *
+ *
+ * $router->setUriSource(Router::URI_SOURCE_SERVER_REQUEST_URI);
+ *
+ */
+ public function setUriSource($uriSource){ }
+
+
+ /**
+ * Set whether router must remove the extra slashes in the handled routes
+ */
+ public function removeExtraSlashes($remove){ }
+
+
+ /**
+ * Sets the name of the default namespace
+ */
+ public function setDefaultNamespace($namespaceName){ }
+
+
+ /**
+ * Sets the name of the default module
+ */
+ public function setDefaultModule($moduleName){ }
+
+
+ /**
+ * Sets the default controller name
+ */
+ public function setDefaultController($controllerName){ }
+
+
+ /**
+ * Sets the default action name
+ */
+ public function setDefaultAction($actionName){ }
+
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ */
+ public function setDefaults($defaults){ }
+
+
+ /**
+ * Returns an array of default parameters
+ */
+ public function getDefaults(){ }
+
+
+ /**
+ * Handles routing information received from the rewrite engine
+ *
+ *
+ * //Read the info from the rewrite engine
+ * $router->handle();
+ *
+ * //Manually passing an URL
+ * $router->handle('/posts/edit/1');
+ *
+ */
+ public function handle($uri=null){ }
+
+
+ /**
+ * Adds a route to the router without any HTTP constraint
+ *
+ *
+ * $router->add('/about', 'About::index');
+ *
+ */
+ public function add($pattern, $paths=null, $httpMethods=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ */
+ public function addGet($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ */
+ public function addPost($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ */
+ public function addPut($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ */
+ public function addPatch($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ */
+ public function addDelete($pattern, $paths=null){ }
+
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ */
+ public function addOptions($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ */
+ public function addHead($pattern, $paths=null){ }
+
+
+ /**
+ * Mounts a group of routes in the router
+ */
+ public function mount(\Phalcon\Mvc\Router\GroupInterface $group){ }
+
+
+ /**
+ * Set a group of paths to be returned when none of the defined routes are matched
+ */
+ public function notFound($paths){ }
+
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear(){ }
+
+
+ /**
+ * Returns the processed namespace name
+ */
+ public function getNamespaceName(){ }
+
+
+ /**
+ * Returns the processed module name
+ */
+ public function getModuleName(){ }
+
+
+ /**
+ * Returns the processed controller name
+ */
+ public function getControllerName(){ }
+
+
+ /**
+ * Returns the processed action name
+ */
+ public function getActionName(){ }
+
+
+ /**
+ * Returns the processed parameters
+ */
+ public function getParams(){ }
+
+
+ /**
+ * Returns the route that matchs the handled URI
+ */
+ public function getMatchedRoute(){ }
+
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ */
+ public function getMatches(){ }
+
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ */
+ public function wasMatched(){ }
+
+
+ /**
+ * Returns all the routes defined in the router
+ */
+ public function getRoutes(){ }
+
+
+ /**
+ * Returns a route object by its id
+ */
+ public function getRouteById($id){ }
+
+
+ /**
+ * Returns a route object by its name
+ */
+ public function getRouteByName($name){ }
+
+
+ /**
+ * Returns whether controller name should not be mangled
+ */
+ public function isExactControllerName(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Router/Annotations.php b/ide/2.0.2/Phalcon/Mvc/Router/Annotations.php
new file mode 100644
index 000000000..0bfbc7961
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Router/Annotations.php
@@ -0,0 +1,99 @@
+
+ * $di['router'] = function() {
+ *
+ * //Use the annotations router
+ * $router = new Annotations(false);
+ *
+ * //This will do the same as above but only if the handled uri starts with /robots
+ * $router->addResource('Robots', '/robots');
+ *
+ * return $router;
+ * };
+ *
+ */
+
+ class Annotations extends \Phalcon\Mvc\Router implements \Phalcon\Mvc\RouterInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ const URI_SOURCE_GET_URL = 0;
+
+ const URI_SOURCE_SERVER_REQUEST_URI = 1;
+
+ protected $_handlers;
+
+ protected $_processed;
+
+ protected $_controllerSuffix;
+
+ protected $_actionSuffix;
+
+ protected $_routePrefix;
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ */
+ public function addResource($handler, $prefix=null){ }
+
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ * The class is located in a module
+ */
+ public function addModuleResource($module, $handler, $prefix=null){ }
+
+
+ /**
+ * Produce the routing parameters from the rewrite information
+ */
+ public function handle($uri=null){ }
+
+
+ /**
+ * Checks for annotations in the controller docblock
+ */
+ public function processControllerAnnotation($handler, \Phalcon\Annotations\Annotation $annotation){ }
+
+
+ /**
+ * Checks for annotations in the public methods of the controller
+ *
+ * @param string module
+ * @param string namespaceName
+ * @param string controller
+ * @param string action
+ * @param \Phalcon\Annotations\Annotation annotation
+ */
+ public function processActionAnnotation($module, $namespaceName, $controller, $action, \Phalcon\Annotations\Annotation $annotation){ }
+
+
+ /**
+ * Changes the controller class suffix
+ */
+ public function setControllerSuffix($controllerSuffix){ }
+
+
+ /**
+ * Changes the action method suffix
+ */
+ public function setActionSuffix($actionSuffix){ }
+
+
+ /**
+ * Return the registered resources
+ *
+ * @return array
+ */
+ public function getResources(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Router/Exception.php b/ide/2.0.2/Phalcon/Mvc/Router/Exception.php
new file mode 100644
index 000000000..047eaf4e1
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Router/Exception.php
@@ -0,0 +1,7 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ *
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ *
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ *
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ *
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ *
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ *
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ *
+ */
+
+ class Group implements \Phalcon\Mvc\Router\GroupInterface {
+
+ protected $_prefix;
+
+ protected $_hostname;
+
+ protected $_paths;
+
+ protected $_routes;
+
+ protected $_beforeMatch;
+
+ /**
+ * \Phalcon\Mvc\Router\Group constructor
+ */
+ public function __construct($paths=null){ }
+
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ */
+ public function setHostname($hostname){ }
+
+
+ /**
+ * Returns the hostname restriction
+ */
+ public function getHostname(){ }
+
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ */
+ public function setPrefix($prefix){ }
+
+
+ /**
+ * Returns the common prefix for all the routes
+ */
+ public function getPrefix(){ }
+
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ */
+ public function beforeMatch($beforeMatch){ }
+
+
+ /**
+ * Returns the 'before match' callback if any
+ */
+ public function getBeforeMatch(){ }
+
+
+ /**
+ * Set common paths for all the routes in the group
+ */
+ public function setPaths($paths){ }
+
+
+ /**
+ * Returns the common paths defined for this group
+ */
+ public function getPaths(){ }
+
+
+ /**
+ * Returns the routes added to the group
+ */
+ public function getRoutes(){ }
+
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ *
+ * router->add('/about', 'About::index');
+ *
+ */
+ public function add($pattern, $paths=null, $httpMethods=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addGet($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPost($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPut($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPatch($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addDelete($pattern, $paths=null){ }
+
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addOptions($pattern, $paths=null){ }
+
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string pattern
+ * @param string/array paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addHead($pattern, $paths=null){ }
+
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear(){ }
+
+
+ /**
+ * Adds a route applying the common attributes
+ */
+ protected function _addRoute($pattern, $paths=null, $httpMethods=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Router/GroupInterface.php b/ide/2.0.2/Phalcon/Mvc/Router/GroupInterface.php
new file mode 100644
index 000000000..a03dd69d9
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Router/GroupInterface.php
@@ -0,0 +1,61 @@
+
+ * $route->via('GET');
+ * $route->via(array('GET', 'POST'));
+ *
+ */
+ public function via($httpMethods){ }
+
+
+ /**
+ * Extracts parameters from a string
+ */
+ public function extractNamedParams($pattern){ }
+
+
+ /**
+ * Reconfigure the route adding a new pattern and a set of paths
+ */
+ public function reConfigure($pattern, $paths=null){ }
+
+
+ /**
+ * Returns the route's name
+ */
+ public function getName(){ }
+
+
+ /**
+ * Sets the route's name
+ *
+ *
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ */
+ public function setName($name){ }
+
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ */
+ public function beforeMatch($callback){ }
+
+
+ /**
+ * Returns the 'before match' callback if any
+ */
+ public function getBeforeMatch(){ }
+
+
+ /**
+ * Returns the route's id
+ */
+ public function getRouteId(){ }
+
+
+ /**
+ * Returns the route's pattern
+ */
+ public function getPattern(){ }
+
+
+ /**
+ * Returns the route's compiled pattern
+ */
+ public function getCompiledPattern(){ }
+
+
+ /**
+ * Returns the paths
+ */
+ public function getPaths(){ }
+
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ */
+ public function getReversedPaths(){ }
+
+
+ /**
+ * Sets a set of HTTP methods that constraint the matching of the route (alias of via)
+ *
+ *
+ * $route->setHttpMethods('GET');
+ * $route->setHttpMethods(array('GET', 'POST'));
+ *
+ */
+ public function setHttpMethods($httpMethods){ }
+
+
+ /**
+ * Returns the HTTP methods that constraint matching the route
+ */
+ public function getHttpMethods(){ }
+
+
+ /**
+ * Sets a hostname restriction to the route
+ *
+ *
+ * $route->setHostname('localhost');
+ *
+ */
+ public function setHostname($hostname){ }
+
+
+ /**
+ * Returns the hostname restriction if any
+ */
+ public function getHostname(){ }
+
+
+ /**
+ * Sets the group associated with the route
+ */
+ public function setGroup(\Phalcon\Mvc\Router\GroupInterface $group){ }
+
+
+ /**
+ * Returns the group associated with the route
+ */
+ public function getGroup(){ }
+
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ */
+ public function convert($name, $converter){ }
+
+
+ /**
+ * Returns the router converter
+ */
+ public function getConverters(){ }
+
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Router/RouteInterface.php b/ide/2.0.2/Phalcon/Mvc/Router/RouteInterface.php
new file mode 100644
index 000000000..7f5b1fbb9
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Router/RouteInterface.php
@@ -0,0 +1,49 @@
+
+ *
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ *
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ *
+ */
+
+ class Url implements \Phalcon\Mvc\UrlInterface, \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_baseUri;
+
+ protected $_staticBaseUri;
+
+ protected $_basePath;
+
+ protected $_router;
+
+ /**
+ * Sets the DependencyInjector container
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the DependencyInjector container
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets a prefix for all the URIs to be generated
+ *
+ *
+ * $url->setBaseUri('/invo/');
+ * $url->setBaseUri('/invo/index.php/');
+ *
+ */
+ public function setBaseUri($baseUri){ }
+
+
+ /**
+ * Sets a prefix for all static URLs generated
+ *
+ *
+ * $url->setStaticBaseUri('/invo/');
+ *
+ */
+ public function setStaticBaseUri($staticBaseUri){ }
+
+
+ /**
+ * Returns the prefix for all the generated urls. By default /
+ */
+ public function getBaseUri(){ }
+
+
+ /**
+ * Returns the prefix for all the generated static urls. By default /
+ */
+ public function getStaticBaseUri(){ }
+
+
+ /**
+ * Sets a base path for all the generated paths
+ *
+ *
+ * $url->setBasePath('/var/www/htdocs/');
+ *
+ */
+ public function setBasePath($basePath){ }
+
+
+ /**
+ * Returns the base path
+ */
+ public function getBasePath(){ }
+
+
+ /**
+ * Generates a URL
+ *
+ *
+ *
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ *
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ *
+ *
+ * @param string|array uri
+ * @param array|object args Optional arguments to be appended to the query string
+ * @param bool $local
+ * @return string
+ */
+ public function get($uri=null, $args=null, $local=null){ }
+
+
+ /**
+ * Generates a URL for a static resource
+ *
+ * @param string|array uri
+ * @return string
+ */
+ public function getStatic($uri=null){ }
+
+
+ /**
+ * Generates a local path
+ *
+ * @param string path
+ * @return string
+ */
+ public function path($path=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/Url/Exception.php b/ide/2.0.2/Phalcon/Mvc/Url/Exception.php
new file mode 100644
index 000000000..e4fceab2a
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/Url/Exception.php
@@ -0,0 +1,7 @@
+
+ * //Setting views directory
+ * $view = new \Phalcon\Mvc\View();
+ * $view->setViewsDir('app/views/');
+ *
+ * $view->start();
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->render('posts', 'recent');
+ * $view->finish();
+ *
+ * //Printing views output
+ * echo $view->getContent();
+ *
+ */
+
+ class View extends \Phalcon\Di\Injectable implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\ViewInterface, \Phalcon\Mvc\ViewBaseInterface {
+
+ const LEVEL_MAIN_LAYOUT = 5;
+
+ const LEVEL_AFTER_TEMPLATE = 4;
+
+ const LEVEL_LAYOUT = 3;
+
+ const LEVEL_BEFORE_TEMPLATE = 2;
+
+ const LEVEL_ACTION_VIEW = 1;
+
+ const LEVEL_NO_RENDER = 0;
+
+ const CACHE_MODE_NONE = 0;
+
+ const CACHE_MODE_INVERSE = 1;
+
+ protected $_options;
+
+ protected $_basePath;
+
+ protected $_content;
+
+ protected $_renderLevel;
+
+ protected $_currentRenderLevel;
+
+ protected $_disabledLevels;
+
+ protected $_viewParams;
+
+ protected $_layout;
+
+ protected $_layoutsDir;
+
+ protected $_partialsDir;
+
+ protected $_viewsDir;
+
+ protected $_templatesBefore;
+
+ protected $_templatesAfter;
+
+ protected $_engines;
+
+ protected $_registeredEngines;
+
+ protected $_mainView;
+
+ protected $_controllerName;
+
+ protected $_actionName;
+
+ protected $_params;
+
+ protected $_pickView;
+
+ protected $_cache;
+
+ protected $_cacheLevel;
+
+ protected $_activeRenderPath;
+
+ protected $_disabled;
+
+ public function getRenderLevel(){ }
+
+
+ public function getCurrentRenderLevel(){ }
+
+
+ public function getRegisteredEngines(){ }
+
+
+ /**
+ * \Phalcon\Mvc\View constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Sets the views directory. Depending of your platform, always add a trailing slash or backslash
+ */
+ public function setViewsDir($viewsDir){ }
+
+
+ /**
+ * Gets views directory
+ */
+ public function getViewsDir(){ }
+
+
+ /**
+ * Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ *
+ * $view->setLayoutsDir('../common/layouts/');
+ *
+ */
+ public function setLayoutsDir($layoutsDir){ }
+
+
+ /**
+ * Gets the current layouts sub-directory
+ */
+ public function getLayoutsDir(){ }
+
+
+ /**
+ * Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ *
+ * $view->setPartialsDir('../common/partials/');
+ *
+ */
+ public function setPartialsDir($partialsDir){ }
+
+
+ /**
+ * Gets the current partials sub-directory
+ */
+ public function getPartialsDir(){ }
+
+
+ /**
+ * Sets base path. Depending of your platform, always add a trailing slash or backslash
+ *
+ *
+ * $view->setBasePath(__DIR__ . '/');
+ *
+ */
+ public function setBasePath($basePath){ }
+
+
+ /**
+ * Sets the render level for the view
+ *
+ *
+ * //Render the view related to the controller only
+ * $this->view->setRenderLevel(View::LEVEL_VIEW);
+ *
+ */
+ public function setRenderLevel($level){ }
+
+
+ /**
+ * Disables a specific level of rendering
+ *
+ *
+ * //Render all levels except ACTION level
+ * $this->view->disableLevel(View::LEVEL_ACTION_VIEW);
+ *
+ *
+ * @param int|array level
+ * @return \Phalcon\Mvc\View
+ */
+ public function disableLevel($level){ }
+
+
+ /**
+ * Sets default view name. Must be a file without extension in the views directory
+ *
+ *
+ * //Renders as main view views-dir/base.phtml
+ * $this->view->setMainView('base');
+ *
+ */
+ public function setMainView($viewPath){ }
+
+
+ /**
+ * Returns the name of the main view
+ */
+ public function getMainView(){ }
+
+
+ /**
+ * Change the layout to be used instead of using the name of the latest controller name
+ *
+ *
+ * $this->view->setLayout('main');
+ *
+ */
+ public function setLayout($layout){ }
+
+
+ /**
+ * Returns the name of the main view
+ */
+ public function getLayout(){ }
+
+
+ /**
+ * Sets a template before the controller layout
+ *
+ * @param string|array templateBefore
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateBefore($templateBefore){ }
+
+
+ /**
+ * Resets any "template before" layouts
+ */
+ public function cleanTemplateBefore(){ }
+
+
+ /**
+ * Sets a "template after" controller layout
+ *
+ * @param string|array templateAfter
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateAfter($templateAfter){ }
+
+
+ /**
+ * Resets any template before layouts
+ */
+ public function cleanTemplateAfter(){ }
+
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string key
+ * @param mixed value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setParamToView($key, $value){ }
+
+
+ /**
+ * Set all the render params
+ *
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array params
+ * @param boolean merge
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVars($params, $merge=null){ }
+
+
+ /**
+ * Set a single view parameter
+ *
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string key
+ * @param mixed value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVar($key, $value){ }
+
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string key
+ * @return mixed
+ */
+ public function getVar($key){ }
+
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView(){ }
+
+
+ /**
+ * Gets the name of the controller rendered
+ *
+ * @return string
+ */
+ public function getControllerName(){ }
+
+
+ /**
+ * Gets the name of the action rendered
+ *
+ * @return string
+ */
+ public function getActionName(){ }
+
+
+ /**
+ * Gets extra parameters of the action rendered
+ *
+ * @return array
+ */
+ public function getParams(){ }
+
+
+ /**
+ * Starts rendering process enabling the output buffering
+ */
+ public function start(){ }
+
+
+ /**
+ * Loads registered template engines, if none is registered it will use \Phalcon\Mvc\View\Engine\Php
+ */
+ protected function _loadTemplateEngines(){ }
+
+
+ /**
+ * Checks whether view exists on registered extensions and render it
+ *
+ * @param array engines
+ * @param string viewPath
+ * @param boolean silence
+ * @param boolean mustClean
+ * @param \Phalcon\Cache\BackendInterface $cache
+ */
+ protected function _engineRender($engines, $viewPath, $silence, $mustClean, \Phalcon\Cache\BackendInterface $cache=null){ }
+
+
+ /**
+ * Register templating engines
+ *
+ *
+ *$this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ *));
+ *
+ */
+ public function registerEngines($engines){ }
+
+
+ /**
+ * Checks whether view exists
+ */
+ public function exists($view){ }
+
+
+ /**
+ * Executes render process from dispatching data
+ *
+ *
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->start()->render('posts', 'recent')->finish();
+ *
+ *
+ * @param string controllerName
+ * @param string actionName
+ * @param array params
+ */
+ public function render($controllerName, $actionName, $params=null){ }
+
+
+ /**
+ * Choose a different view to render instead of last-controller/last-action
+ *
+ *
+ * class ProductsController extends \Phalcon\Mvc\Controller
+ * {
+ *
+ * public function saveAction()
+ * {
+ *
+ * //Do some save stuff...
+ *
+ * //Then show the list view
+ * $this->view->pick("products/list");
+ * }
+ * }
+ *
+ *
+ * @param string|array renderView
+ * @return \Phalcon\Mvc\View
+ */
+ public function pick($renderView){ }
+
+
+ /**
+ * Renders a partial view
+ *
+ *
+ * //Retrieve the contents of a partial
+ * echo $this->getPartial('shared/footer');
+ *
+ *
+ *
+ * //Retrieve the contents of a partial with arguments
+ * echo $this->getPartial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string partialPath
+ * @param array params
+ * @return string
+ */
+ public function getPartial($partialPath, $params=null){ }
+
+
+ /**
+ * Renders a partial view
+ *
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string partialPath
+ * @param array params
+ */
+ public function partial($partialPath, $params=null){ }
+
+
+ /**
+ * Perform the automatic rendering returning the output as a string
+ *
+ *
+ * $template = $this->view->getRender('products', 'show', array('products' => $products));
+ *
+ *
+ * @param string controllerName
+ * @param string actionName
+ * @param array params
+ * @param mixed configCallback
+ * @return string
+ */
+ public function getRender($controllerName, $actionName, $params=null, $configCallback=null){ }
+
+
+ /**
+ * Finishes the render process by stopping the output buffering
+ */
+ public function finish(){ }
+
+
+ /**
+ * Create a \Phalcon\Cache based on the internal cache options
+ */
+ protected function _createCache(){ }
+
+
+ /**
+ * Check if the component is currently caching the output content
+ */
+ public function isCaching(){ }
+
+
+ /**
+ * Returns the cache instance used to cache
+ */
+ public function getCache(){ }
+
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param boolean|array options
+ * @return \Phalcon\Mvc\View
+ */
+ public function cache($options=null){ }
+
+
+ /**
+ * Externally sets the view content
+ *
+ *
+ * $this->view->setContent("hello
");
+ *
+ */
+ public function setContent($content){ }
+
+
+ /**
+ * Returns cached output from another view stage
+ */
+ public function getContent(){ }
+
+
+ /**
+ * Returns the path of the view that is currently rendered
+ */
+ public function getActiveRenderPath(){ }
+
+
+ /**
+ * Disables the auto-rendering process
+ */
+ public function disable(){ }
+
+
+ /**
+ * Enables the auto-rendering process
+ */
+ public function enable(){ }
+
+
+ /**
+ * Resets the view component to its factory default values
+ */
+ public function reset(){ }
+
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string key
+ * @param mixed value
+ */
+ public function __set($key, $value){ }
+
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string key
+ * @return mixed
+ */
+ public function __get($key){ }
+
+
+ /**
+ * Whether automatic rendering is enabled
+ */
+ public function isDisabled(){ }
+
+
+ /**
+ * Magic method to retrieve if a variable is set in the view
+ *
+ *
+ * echo isset($this->view->products);
+ *
+ *
+ * @param string key
+ * @return boolean
+ */
+ public function __isset($key){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/View/Engine.php b/ide/2.0.2/Phalcon/Mvc/View/Engine.php
new file mode 100644
index 000000000..bd450ddab
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/View/Engine.php
@@ -0,0 +1,44 @@
+
+ * $compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();
+ *
+ * $compiler->compile('views/partials/header.volt');
+ *
+ * require $compiler->getCompiledTemplatePath();
+ *
+ */
+
+ class Compiler implements \Phalcon\Di\InjectionAwareInterface {
+
+ protected $_dependencyInjector;
+
+ protected $_view;
+
+ protected $_options;
+
+ protected $_arrayHelpers;
+
+ protected $_level;
+
+ protected $_foreachLevel;
+
+ protected $_blockLevel;
+
+ protected $_exprLevel;
+
+ protected $_extended;
+
+ protected $_autoescape;
+
+ protected $_extendedBlocks;
+
+ protected $_currentBlock;
+
+ protected $_blocks;
+
+ protected $_forElsePointers;
+
+ protected $_loopPointers;
+
+ protected $_extensions;
+
+ protected $_functions;
+
+ protected $_filters;
+
+ protected $_macros;
+
+ protected $_prefix;
+
+ protected $_currentPath;
+
+ protected $_compiledTemplatePath;
+
+ /**
+ * \Phalcon\Mvc\View\Engine\Volt\Compiler
+ */
+ public function __construct(\Phalcon\Mvc\ViewBaseInterface $view=null){ }
+
+
+ /**
+ * Sets the dependency injector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the internal dependency injector
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets the compiler options
+ */
+ public function setOptions($options){ }
+
+
+ /**
+ * Sets a single compiler option
+ *
+ * @param string option
+ * @param mixed value
+ */
+ public function setOption($option, $value){ }
+
+
+ /**
+ * Returns a compiler's option
+ *
+ * @param string option
+ * @return string
+ */
+ public function getOption($option){ }
+
+
+ /**
+ * Returns the compiler options
+ */
+ public function getOptions(){ }
+
+
+ /**
+ * Fires an event to registered extensions
+ *
+ * @param string name
+ * @param array arguments
+ * @return mixed
+ */
+ final public function fireExtensionEvent($name, $arguments=null){ }
+
+
+ /**
+ * Registers a Volt's extension
+ *
+ * @param object extension
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+ */
+ public function addExtension($extension){ }
+
+
+ /**
+ * Returns the list of extensions registered in Volt
+ */
+ public function getExtensions(){ }
+
+
+ /**
+ * Register a new function in the compiler
+ *
+ * @param string name
+ * @param Closure|string definition
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+ */
+ public function addFunction($name, $definition){ }
+
+
+ /**
+ * Register the user registered functions
+ */
+ public function getFunctions(){ }
+
+
+ /**
+ * Register a new filter in the compiler
+ *
+ * @param string name
+ * @param Closure|string definition
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+ */
+ public function addFilter($name, $definition){ }
+
+
+ /**
+ * Register the user registered filters
+ */
+ public function getFilters(){ }
+
+
+ /**
+ * Set a unique prefix to be used as prefix for compiled variables
+ */
+ public function setUniquePrefix($prefix){ }
+
+
+ /**
+ * Return a unique prefix to be used as prefix for compiled variables and contexts
+ */
+ public function getUniquePrefix(){ }
+
+
+ /**
+ * Resolves attribute reading
+ */
+ public function attributeReader($expr){ }
+
+
+ /**
+ * Resolves function intermediate code into PHP function calls
+ */
+ public function functionCall($expr){ }
+
+
+ /**
+ * Resolves filter intermediate code into a valid PHP expression
+ */
+ public function resolveTest($test, $left){ }
+
+
+ /**
+ * Resolves filter intermediate code into PHP function calls
+ */
+ final protected function resolveFilter($filter, $left){ }
+
+
+ /**
+ * Resolves an expression node in an AST volt tree
+ */
+ final public function expression($expr){ }
+
+
+ /**
+ * Compiles a block of statements
+ *
+ * @param array statements
+ * @return string|array
+ */
+ final protected function _statementListOrExtends($statements){ }
+
+
+ /**
+ * Compiles a "foreach" intermediate code representation into plain PHP code
+ */
+ public function compileForeach($statement, $extendsMode=null){ }
+
+
+ /**
+ * Generates a 'forelse' PHP code
+ */
+ public function compileForElse(){ }
+
+
+ /**
+ * Compiles a 'if' statement returning PHP code
+ */
+ public function compileIf($statement, $extendsMode=null){ }
+
+
+ /**
+ * Compiles a "elseif" statement returning PHP code
+ */
+ public function compileElseIf($statement){ }
+
+
+ /**
+ * Compiles a "cache" statement returning PHP code
+ */
+ public function compileCache($statement, $extendsMode=null){ }
+
+
+ /**
+ * Compiles a "set" statement returning PHP code
+ */
+ public function compileSet($statement){ }
+
+
+ /**
+ * Compiles a "do" statement returning PHP code
+ */
+ public function compileDo($statement){ }
+
+
+ /**
+ * Compiles a "return" statement returning PHP code
+ */
+ public function compileReturn($statement){ }
+
+
+ /**
+ * Compiles a "autoescape" statement returning PHP code
+ */
+ public function compileAutoEscape($statement, $extendsMode){ }
+
+
+ /**
+ * Compiles a '{{' '}}' statement returning PHP code
+ *
+ * @param array statement
+ * @param boolean extendsMode
+ * @return string
+ */
+ public function compileEcho($statement){ }
+
+
+ /**
+ * Compiles a 'include' statement returning PHP code
+ */
+ public function compileInclude($statement){ }
+
+
+ /**
+ * Compiles macros
+ */
+ public function compileMacro($statement, $extendsMode){ }
+
+
+ /**
+ * Compiles calls to macros
+ *
+ * @param array statement
+ * @param boolean extendsMode
+ * @return string
+ */
+ public function compileCall($statement, $extendsMode){ }
+
+
+ /**
+ * Traverses a statement list compiling each of its nodes
+ */
+ final protected function _statementList($statements, $extendsMode=null){ }
+
+
+ /**
+ * Compiles a Volt source code returning a PHP plain version
+ */
+ protected function _compileSource($viewCode, $extendsMode=null){ }
+
+
+ /**
+ * Compiles a template into a string
+ *
+ *
+ * echo $compiler->compileString('{{ "hello world" }}');
+ *
+ */
+ public function compileString($viewCode, $extendsMode=null){ }
+
+
+ /**
+ * Compiles a template into a file forcing the destination path
+ *
+ *
+ * $compiler->compile('views/layouts/main.volt', 'views/layouts/main.volt.php');
+ *
+ *
+ * @param string path
+ * @param string compiledPath
+ * @param boolean extendsMode
+ * @return string|array
+ */
+ public function compileFile($path, $compiledPath, $extendsMode=null){ }
+
+
+ /**
+ * Compiles a template into a file applying the compiler options
+ * This method does not return the compiled path if the template was not compiled
+ *
+ *
+ * $compiler->compile('views/layouts/main.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ *
+ * @param string templatePath
+ * @param boolean extendsMode
+ * @return string|array
+ */
+ public function compile($templatePath, $extendsMode=null){ }
+
+
+ /**
+ * Returns the path that is currently being compiled
+ */
+ public function getTemplatePath(){ }
+
+
+ /**
+ * Returns the path to the last compiled template
+ */
+ public function getCompiledTemplatePath(){ }
+
+
+ /**
+ * Parses a Volt template returning its intermediate representation
+ *
+ *
+ * print_r($compiler->parse('{{ 3 + 2 }}'));
+ *
+ *
+ * @param string viewCode
+ * @return array
+ */
+ public function parse($viewCode){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/View/EngineInterface.php b/ide/2.0.2/Phalcon/Mvc/View/EngineInterface.php
new file mode 100644
index 000000000..987e1d00f
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/View/EngineInterface.php
@@ -0,0 +1,19 @@
+
+ * $view = new \Phalcon\Mvc\View\Simple();
+ * echo $view->render('templates/my-view', array('content' => $html));
+ * //or with filename with extension
+ * echo $view->render('templates/my-view.volt', array('content' => $html));
+ *
+ */
+
+ class Simple extends \Phalcon\Di\Injectable implements \Phalcon\Events\EventsAwareInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\ViewBaseInterface {
+
+ protected $_options;
+
+ protected $_viewsDir;
+
+ protected $_partialsDir;
+
+ protected $_viewParams;
+
+ protected $_engines;
+
+ protected $_registeredEngines;
+
+ protected $_activeRenderPath;
+
+ protected $_content;
+
+ protected $_cache;
+
+ protected $_cacheOptions;
+
+ public function getRegisteredEngines(){ }
+
+
+ /**
+ * \Phalcon\Mvc\View\Simple constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ /**
+ * Sets views directory. Depending of your platform, always add a trailing slash or backslash
+ */
+ public function setViewsDir($viewsDir){ }
+
+
+ /**
+ * Gets views directory
+ */
+ public function getViewsDir(){ }
+
+
+ /**
+ * Register templating engines
+ *
+ *
+ *$this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ *));
+ *
+ */
+ public function registerEngines($engines){ }
+
+
+ /**
+ * Loads registered template engines, if none is registered it will use \Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines(){ }
+
+
+ /**
+ * Tries to render the view with every engine registered in the component
+ *
+ * @param string path
+ * @param array params
+ */
+ final protected function _internalRender($path, $params){ }
+
+
+ /**
+ * Renders a view
+ *
+ * @param string path
+ * @param array params
+ * @return string
+ */
+ public function render($path, $params=null){ }
+
+
+ /**
+ * Renders a partial view
+ *
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string partialPath
+ * @param array params
+ */
+ public function partial($partialPath, $params=null){ }
+
+
+ /**
+ * Sets the cache options
+ *
+ * @param array options
+ * @return \Phalcon\Mvc\View\Simple
+ */
+ public function setCacheOptions($options){ }
+
+
+ /**
+ * Returns the cache options
+ *
+ * @return array
+ */
+ public function getCacheOptions(){ }
+
+
+ /**
+ * Create a \Phalcon\Cache based on the internal cache options
+ */
+ protected function _createCache(){ }
+
+
+ /**
+ * Returns the cache instance used to cache
+ */
+ public function getCache(){ }
+
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ */
+ public function cache($options=null){ }
+
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ */
+ public function setParamToView($key, $value){ }
+
+
+ /**
+ * Set all the render params
+ *
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ */
+ public function setVars($params, $merge=null){ }
+
+
+ /**
+ * Set a single view parameter
+ *
+ *
+ * $this->view->setVar('products', $products);
+ *
+ */
+ public function setVar($key, $value){ }
+
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string key
+ * @return mixed
+ */
+ public function getVar($key){ }
+
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView(){ }
+
+
+ /**
+ * Externally sets the view content
+ *
+ *
+ * $this->view->setContent("hello
");
+ *
+ */
+ public function setContent($content){ }
+
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent(){ }
+
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath(){ }
+
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ *
+ * $this->view->products = $products;
+ *
+ */
+ public function __set($key, $value){ }
+
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string key
+ * @return mixed
+ */
+ public function __get($key){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Mvc/ViewBaseInterface.php b/ide/2.0.2/Phalcon/Mvc/ViewBaseInterface.php
new file mode 100644
index 000000000..7ccfaca52
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Mvc/ViewBaseInterface.php
@@ -0,0 +1,34 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => Robots::find(),
+ * "limit" => 25,
+ * "page" => $currentPage
+ * )
+ * );
+ *
+ * $paginate = $paginator->getPaginate();
+ *
+ */
+
+ class Model extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface {
+
+ protected $_config;
+
+ /**
+ * \Phalcon\Paginator\Adapter\Model constructor
+ */
+ public function __construct($config){ }
+
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ */
+ public function getPaginate(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Paginator/Adapter/NativeArray.php b/ide/2.0.2/Phalcon/Paginator/Adapter/NativeArray.php
new file mode 100644
index 000000000..faa3c3425
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Paginator/Adapter/NativeArray.php
@@ -0,0 +1,44 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => array(
+ * array('id' => 1, 'name' => 'Artichoke'),
+ * array('id' => 2, 'name' => 'Carrots'),
+ * array('id' => 3, 'name' => 'Beet'),
+ * array('id' => 4, 'name' => 'Lettuce'),
+ * array('id' => 5, 'name' => '')
+ * ),
+ * "limit" => 2,
+ * "page" => $currentPage
+ * )
+ * );
+ *
+ *
+ */
+
+ class NativeArray extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface {
+
+ protected $_config;
+
+ /**
+ * \Phalcon\Paginator\Adapter\NativeArray constructor
+ */
+ public function __construct($config){ }
+
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ */
+ public function getPaginate(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Paginator/Adapter/QueryBuilder.php b/ide/2.0.2/Phalcon/Paginator/Adapter/QueryBuilder.php
new file mode 100644
index 000000000..4b7c2b6ba
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Paginator/Adapter/QueryBuilder.php
@@ -0,0 +1,60 @@
+
+ * $builder = $this->modelsManager->createBuilder()
+ * ->columns('id, name')
+ * ->from('Robots')
+ * ->orderBy('name');
+ *
+ * $paginator = new Phalcon\Paginator\Adapter\QueryBuilder(array(
+ * "builder" => $builder,
+ * "limit"=> 20,
+ * "page" => 1
+ * ));
+ *
+ */
+
+ class QueryBuilder extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface {
+
+ protected $_config;
+
+ protected $_builder;
+
+ /**
+ * \Phalcon\Paginator\Adapter\QueryBuilder
+ */
+ public function __construct($config){ }
+
+
+ /**
+ * Get the current page number
+ */
+ public function getCurrentPage(){ }
+
+
+ /**
+ * Set query builder object
+ */
+ public function setQueryBuilder(\Phalcon\Mvc\Model\Query\Builder $builder){ }
+
+
+ /**
+ * Get query builder object
+ */
+ public function getQueryBuilder(){ }
+
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ */
+ public function getPaginate(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Paginator/AdapterInterface.php b/ide/2.0.2/Phalcon/Paginator/AdapterInterface.php
new file mode 100644
index 000000000..e811cf68d
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Paginator/AdapterInterface.php
@@ -0,0 +1,22 @@
+
+ * $registry = new \Phalcon\Registry();
+ *
+ * // Set value
+ * $registry->something = 'something';
+ * // or
+ * $registry['something'] = 'something';
+ *
+ * // Get value
+ * $value = $registry->something;
+ * // or
+ * $value = $registry['something'];
+ *
+ * // Check if the key exists
+ * $exists = isset($registry->something);
+ * // or
+ * $exists = isset($registry['something']);
+ *
+ * // Unset
+ * unset($registry->something);
+ * // or
+ * unset($registry['something']);
+ *
+ *
+ * In addition to ArrayAccess, Phalcon\Registry also implements Countable
+ * (count($registry) will return the number of elements in the registry),
+ * Serializable and Iterator (you can iterate over the registry
+ * using a foreach loop) interfaces. For PHP 5.4 and higher, JsonSerializable
+ * interface is implemented.
+ *
+ * Phalcon\Registry is very fast (it is typically faster than any userspace
+ * implementation of the registry); however, this comes at a price:
+ * Phalcon\Registry is a final class and cannot be inherited from.
+ *
+ * Though Phalcon\Registry exposes methods like __get(), offsetGet(), count() etc,
+ * it is not recommended to invoke them manually (these methods exist mainly to
+ * match the interfaces the registry implements): $registry->__get('property')
+ * is several times slower than $registry->property.
+ *
+ * Internally all the magic methods (and interfaces except JsonSerializable)
+ * are implemented using object handlers or similar techniques: this allows
+ * to bypass relatively slow method calls.
+ */
+
+ final class Registry implements \ArrayAccess, \Countable, \Iterator, \Traversable {
+
+ protected $_data;
+
+ /**
+ * Registry constructor
+ */
+ final public function __construct(){ }
+
+
+ /**
+ * Checks if the element is present in the registry
+ */
+ final public function offsetExists($offset){ }
+
+
+ /**
+ * Returns an index in the registry
+ */
+ final public function offsetGet($offset){ }
+
+
+ /**
+ * Sets an element in the registry
+ */
+ final public function offsetSet($offset, $value){ }
+
+
+ /**
+ * Unsets an element in the registry
+ */
+ final public function offsetUnset($offset){ }
+
+
+ /**
+ * Checks how many elements are in the register
+ */
+ final public function count(){ }
+
+
+ /**
+ * Moves cursor to next row in the registry
+ */
+ final public function next(){ }
+
+
+ /**
+ * Gets pointer number of active row in the registry
+ */
+ final public function key(){ }
+
+
+ /**
+ * Rewinds the registry cursor to its beginning
+ */
+ final public function rewind(){ }
+
+
+ /**
+ * Checks if the iterator is valid
+ */
+ public function valid(){ }
+
+
+ /**
+ * Obtains the current value in the internal iterator
+ */
+ public function current(){ }
+
+
+ /**
+ * Sets an element in the registry
+ */
+ final public function __set($key, $value){ }
+
+
+ /**
+ * Returns an index in the registry
+ */
+ final public function __get($key){ }
+
+
+ final public function __isset($key){ }
+
+
+ final public function __unset($key){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Security.php b/ide/2.0.2/Phalcon/Security.php
new file mode 100644
index 000000000..f87b7c192
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Security.php
@@ -0,0 +1,164 @@
+
+ * $login = $this->request->getPost('login');
+ * $password = $this->request->getPost('password');
+ *
+ * $user = Users::findFirstByLogin($login);
+ * if ($user) {
+ * if ($this->security->checkHash($password, $user->password)) {
+ * //The password is valid
+ * }
+ * }
+ *
+ */
+
+ class Security implements \Phalcon\Di\InjectionAwareInterface {
+
+ const CRYPT_DEFAULT = 0;
+
+ const CRYPT_STD_DES = 1;
+
+ const CRYPT_EXT_DES = 2;
+
+ const CRYPT_MD5 = 3;
+
+ const CRYPT_BLOWFISH = 4;
+
+ const CRYPT_BLOWFISH_X = 5;
+
+ const CRYPT_BLOWFISH_Y = 6;
+
+ const CRYPT_SHA256 = 7;
+
+ const CRYPT_SHA512 = 8;
+
+ protected $_dependencyInjector;
+
+ protected $_workFactor;
+
+ protected $_numberBytes;
+
+ protected $_tokenKeySessionID;
+
+ protected $_tokenValueSessionID;
+
+ protected $_csrf;
+
+ protected $_defaultHash;
+
+ public function setWorkFactor($workFactor){ }
+
+
+ public function getWorkFactor(){ }
+
+
+ /**
+ * Sets the dependency injector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the internal dependency injector
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Sets a number of bytes to be generated by the openssl pseudo random generator
+ */
+ public function setRandomBytes($randomBytes){ }
+
+
+ /**
+ * Returns a number of bytes to be generated by the openssl pseudo random generator
+ */
+ public function getRandomBytes(){ }
+
+
+ /**
+ * Generate a >22-length pseudo random string to be used as salt for passwords
+ */
+ public function getSaltBytes($numberBytes=null){ }
+
+
+ /**
+ * Creates a password hash using bcrypt with a pseudo random salt
+ */
+ public function hash($password, $workFactor=null){ }
+
+
+ /**
+ * Checks a plain text password and its hash version to check if the password matches
+ */
+ public function checkHash($password, $passwordHash, $maxPassLength=null){ }
+
+
+ /**
+ * Checks if a password hash is a valid bcrypt's hash
+ */
+ public function isLegacyHash($passwordHash){ }
+
+
+ /**
+ * Generates a pseudo random token key to be used as input's name in a CSRF check
+ */
+ public function getTokenKey($numberBytes=null){ }
+
+
+ /**
+ * Generates a pseudo random token value to be used as input's value in a CSRF check
+ */
+ public function getToken($numberBytes=null){ }
+
+
+ /**
+ * Check if the CSRF token sent in the request is the same that the current in session
+ */
+ public function checkToken($tokenKey=null, $tokenValue=null, $destroyIfValid=null){ }
+
+
+ /**
+ * Returns the value of the CSRF token in session
+ */
+ public function getSessionToken(){ }
+
+
+ /**
+ * Removes the value of the CSRF token and key from session
+ */
+ public function destroyToken(){ }
+
+
+ /**
+ * Computes a HMAC
+ *
+ * @param string data
+ * @param string key
+ * @param string algo
+ * @param boolean raw
+ */
+ public function computeHmac($data, $key, $algo, $raw=null){ }
+
+
+ /**
+ * Sets the default hash
+ */
+ public function setDefaultHash($defaultHash){ }
+
+
+ /**
+ * Sets the default hash
+ */
+ public function getDefaultHash(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Security/Exception.php b/ide/2.0.2/Phalcon/Security/Exception.php
new file mode 100644
index 000000000..e69e2a3de
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Security/Exception.php
@@ -0,0 +1,7 @@
+
+ * session->setOptions(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ *
+ *
+ * @param array options
+ */
+ public function setOptions($options){ }
+
+
+ /**
+ * Get internal options
+ *
+ * @return array
+ */
+ public function getOptions(){ }
+
+
+ /**
+ * Gets a session variable from an application context
+ *
+ * @param string index
+ * @param mixed defaultValue
+ * @param boolean remove
+ * @return mixed
+ */
+ public function get($index, $defaultValue=null, $remove=null){ }
+
+
+ /**
+ * Sets a session variable in an application context
+ *
+ *
+ * session->set('auth', 'yes');
+ *
+ *
+ * @param string index
+ * @param string value
+ */
+ public function set($index, $value){ }
+
+
+ /**
+ * Check whether a session variable is set in an application context
+ *
+ *
+ * var_dump($session->has('auth'));
+ *
+ *
+ * @param string index
+ */
+ public function has($index){ }
+
+
+ /**
+ * Removes a session variable from an application context
+ *
+ *
+ * $session->remove('auth');
+ *
+ */
+ public function remove($index){ }
+
+
+ /**
+ * Returns active session id
+ *
+ *
+ * echo $session->getId();
+ *
+ */
+ public function getId(){ }
+
+
+ /**
+ * Set the current session id
+ *
+ *
+ * $session->setId($id);
+ *
+ *
+ * @param string id
+ */
+ public function setId($id){ }
+
+
+ /**
+ * Check whether the session has been started
+ *
+ *
+ * var_dump($session->isStarted());
+ *
+ */
+ public function isStarted(){ }
+
+
+ /**
+ * Destroys the active session
+ *
+ *
+ * var_dump($session->destroy());
+ *
+ */
+ public function destroy(){ }
+
+
+ /**
+ * Returns the status of the current session. For PHP 5.3 this function will always return SESSION_NONE
+ *
+ *
+ * var_dump($session->status());
+ *
+ * // PHP 5.4 and above will give meaningful messages, 5.3 gets SESSION_NONE always
+ * if ($session->status() !== $session::SESSION_ACTIVE) {
+ * $session->start();
+ * }
+ *
+ */
+ public function status(){ }
+
+
+ /**
+ * Alias: Gets a session variable from an application context
+ *
+ * @param string index
+ * @return mixed
+ */
+ public function __get($index){ }
+
+
+ /**
+ * Alias: Sets a session variable in an application context
+ *
+ * @param string index
+ * @param string value
+ */
+ public function __set($index, $value){ }
+
+
+ /**
+ * Alias: Check whether a session variable is set in an application context
+ *
+ * @param string index
+ */
+ public function __isset($index){ }
+
+
+ /**
+ * Alias: Removes a session variable from an application context
+ */
+ public function __unset($index){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Session/Adapter/Files.php b/ide/2.0.2/Phalcon/Session/Adapter/Files.php
new file mode 100644
index 000000000..db52a8e52
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Session/Adapter/Files.php
@@ -0,0 +1,13 @@
+
+ * $session = new Phalcon\Session\Adapter\Libmemcached(array(
+ * 'servers' => array(
+ * array('host' => 'localhost', 'port' => 11211, 'weight' => 1),
+ * ),
+ * 'client' => array(
+ * Memcached::OPT_HASH => Memcached::HASH_MD5,
+ * Memcached::OPT_PREFIX_KEY => 'prefix.',
+ * ),
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ *
+ * $session->start();
+ *
+ * $session->set('var', 'some-value');
+ *
+ * echo $session->get('var');
+ *
+ */
+
+ class Libmemcached extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface {
+
+ const SESSION_ACTIVE = 2;
+
+ const SESSION_NONE = 1;
+
+ const SESSION_DISABLED = 0;
+
+ protected $_libmemcached;
+
+ protected $_lifetime;
+
+ public function getLibmemcached(){ }
+
+
+ public function getLifetime(){ }
+
+
+ /**
+ * \Phalcon\Session\Adapter\Libmemcached constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ public function open(){ }
+
+
+ public function close(){ }
+
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string sessionId
+ * @return mixed
+ */
+ public function read($sessionId){ }
+
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string sessionId
+ * @param string data
+ */
+ public function write($sessionId, $data){ }
+
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string sessionId
+ * @return boolean
+ */
+ public function destroy($session_id=null){ }
+
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gc(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Session/Adapter/Memcache.php b/ide/2.0.2/Phalcon/Session/Adapter/Memcache.php
new file mode 100644
index 000000000..c8d6e99ec
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Session/Adapter/Memcache.php
@@ -0,0 +1,93 @@
+
+ * $session = new \Phalcon\Session\Adapter\Memcache(array(
+ * 'uniqueId' => 'my-private-app'
+ * 'host' => '127.0.0.1',
+ * 'port' => 11211,
+ * 'persistent' => TRUE,
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ *
+ * $session->start();
+ *
+ * $session->set('var', 'some-value');
+ *
+ * echo $session->get('var');
+ *
+ */
+
+ class Memcache extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface {
+
+ const SESSION_ACTIVE = 2;
+
+ const SESSION_NONE = 1;
+
+ const SESSION_DISABLED = 0;
+
+ protected $_memcache;
+
+ protected $_lifetime;
+
+ public function getMemcache(){ }
+
+
+ public function getLifetime(){ }
+
+
+ /**
+ * \Phalcon\Session\Adapter\Memcache constructor
+ *
+ * @param array options
+ */
+ public function __construct($options=null){ }
+
+
+ public function open(){ }
+
+
+ public function close(){ }
+
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string sessionId
+ * @return mixed
+ */
+ public function read($sessionId){ }
+
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string sessionId
+ * @param string data
+ */
+ public function write($sessionId, $data){ }
+
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string sessionId
+ * @return boolean
+ */
+ public function destroy($session_id=null){ }
+
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gc(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Session/AdapterInterface.php b/ide/2.0.2/Phalcon/Session/AdapterInterface.php
new file mode 100644
index 000000000..354a24649
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Session/AdapterInterface.php
@@ -0,0 +1,37 @@
+
+ * $user = new \Phalcon\Session\Bag('user');
+ * $user->name = "Kimbra Johnson";
+ * $user->age = 22;
+ *
+ */
+
+ class Bag implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Session\BagInterface, \IteratorAggregate, \Traversable, \ArrayAccess, \Countable {
+
+ protected $_dependencyInjector;
+
+ protected $_name;
+
+ protected $_data;
+
+ protected $_initialized;
+
+ protected $_session;
+
+ /**
+ * \Phalcon\Session\Bag constructor
+ *
+ * @param string name
+ */
+ public function __construct($name){ }
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param \Phalcon\DiInterface dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector){ }
+
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI(){ }
+
+
+ /**
+ * Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed
+ */
+ public function initialize(){ }
+
+
+ /**
+ * Destroyes the session bag
+ *
+ *
+ * $user->destroy();
+ *
+ */
+ public function destroy(){ }
+
+
+ /**
+ * Sets a value in the session bag
+ *
+ *
+ * $user->set('name', 'Kimbra');
+ *
+ *
+ * @param string property
+ * @param string value
+ */
+ public function set($property, $value){ }
+
+
+ /**
+ * Magic setter to assign values to the session bag
+ *
+ *
+ * $user->name = "Kimbra";
+ *
+ *
+ * @param string property
+ * @param string value
+ */
+ public function __set($property, $value){ }
+
+
+ /**
+ * Obtains a value from the session bag optionally setting a default value
+ *
+ *
+ * echo $user->get('name', 'Kimbra');
+ *
+ *
+ * @param string property
+ * @param string defaultValue
+ * @return mixed
+ */
+ public function get($property, $defaultValue=null){ }
+
+
+ /**
+ * Magic getter to obtain values from the session bag
+ *
+ *
+ * echo $user->name;
+ *
+ *
+ * @param string property
+ * @return mixed
+ */
+ public function __get($property){ }
+
+
+ /**
+ * Check whether a property is defined in the internal bag
+ *
+ *
+ * var_dump($user->has('name'));
+ *
+ *
+ * @param string property
+ * @return boolean
+ */
+ public function has($property){ }
+
+
+ /**
+ * Magic isset to check whether a property is defined in the bag
+ *
+ *
+ * var_dump(isset($user['name']));
+ *
+ *
+ * @param string property
+ * @return boolean
+ */
+ public function __isset($property){ }
+
+
+ /**
+ * Removes a property from the internal bag
+ *
+ *
+ * $user->remove('name');
+ *
+ *
+ * @param string property
+ * @return boolean
+ */
+ public function remove($property){ }
+
+
+ /**
+ * Magic unset to remove items using the array syntax
+ *
+ *
+ * unset($user['name']);
+ *
+ *
+ * @param string property
+ * @return boolean
+ */
+ public function __unset($property){ }
+
+
+ /**
+ * Return length of bag
+ *
+ *
+ * echo $user->count();
+ *
+ *
+ * @return int
+ */
+ final public function count(){ }
+
+
+ final public function getIterator(){ }
+
+
+ final public function offsetSet($property, $value){ }
+
+
+ final public function offsetExists($property){ }
+
+
+ final public function offsetUnset($property){ }
+
+
+ final public function offsetGet($property){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Session/BagInterface.php b/ide/2.0.2/Phalcon/Session/BagInterface.php
new file mode 100644
index 000000000..c01b3cb69
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Session/BagInterface.php
@@ -0,0 +1,31 @@
+
+ * //Assigning "peter" to "name" component
+ * \Phalcon\Tag::setDefault("name", "peter");
+ *
+ * //Later in the view
+ * echo \Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param string id
+ * @param string value
+ */
+ public static function setDefault($id, $value){ }
+
+
+ /**
+ * Assigns default values to generated tags by helpers
+ *
+ *
+ * //Assigning "peter" to "name" component
+ * \Phalcon\Tag::setDefaults(array("name" => "peter"));
+ *
+ * //Later in the view
+ * echo \Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ */
+ public static function setDefaults($values, $merge=null){ }
+
+
+ /**
+ * Alias of \Phalcon\Tag::setDefault
+ *
+ * @param string id
+ * @param string value
+ */
+ public static function displayTo($id, $value){ }
+
+
+ /**
+ * Check if a helper has a default value set using \Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string name
+ * @return boolean
+ */
+ public static function hasValue($name){ }
+
+
+ /**
+ * Every helper calls this function to check whether a component has a predefined
+ * value using \Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string name
+ * @param array params
+ * @return mixed
+ */
+ public static function getValue($name, $params=null){ }
+
+
+ /**
+ * Resets the request and internal values to avoid those fields will have any default value
+ */
+ public static function resetInput(){ }
+
+
+ /**
+ * Builds a HTML A tag using framework conventions
+ *
+ *
+ * echo \Phalcon\Tag::linkTo("signup/register", "Register Here!");
+ * echo \Phalcon\Tag::linkTo(array("signup/register", "Register Here!"));
+ * echo \Phalcon\Tag::linkTo(array("signup/register", "Register Here!", "class" => "btn-primary"));
+ * echo \Phalcon\Tag::linkTo("http://phalconphp.com/", "Phalcon", FALSE);
+ * echo \Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", FALSE));
+ * echo \Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", "local" =>FALSE));
+ *
+ *
+ * @param array|string parameters
+ * @param string text
+ * @param boolean local
+ * @return string
+ */
+ public static function linkTo($parameters, $text=null, $local=null){ }
+
+
+ /**
+ * Builds generic INPUT tags
+ *
+ * @param string type
+ * @param array parameters
+ * @param boolean asValue
+ * @return string
+ */
+ final protected static function _inputField($type, $parameters, $asValue=null){ }
+
+
+ /**
+ * Builds INPUT tags that implements the checked attribute
+ *
+ * @param string type
+ * @param array parameters
+ * @return string
+ */
+ final protected static function _inputFieldChecked($type, $parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="color"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function colorField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="text"] tag
+ *
+ *
+ * echo \Phalcon\Tag::textField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function textField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="number"] tag
+ *
+ *
+ * echo \Phalcon\Tag::numericField(array("price", "min" => "1", "max" => "5"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function numericField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="range"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function rangeField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="email"] tag
+ *
+ *
+ * echo \Phalcon\Tag::emailField("email");
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function emailField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="date"] tag
+ *
+ *
+ * echo \Phalcon\Tag::dateField(array("born", "value" => "14-12-1980"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function dateField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="datetime"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function dateTimeField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="datetime-local"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function dateTimeLocalField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="month"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function monthField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="time"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function timeField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="week"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function weekField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="password"] tag
+ *
+ *
+ * echo \Phalcon\Tag::passwordField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function passwordField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="hidden"] tag
+ *
+ *
+ * echo \Phalcon\Tag::hiddenField(array("name", "value" => "mike"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function hiddenField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="file"] tag
+ *
+ *
+ * echo \Phalcon\Tag::fileField("file");
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function fileField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="search"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function searchField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="tel"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function telField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="url"] tag
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function urlField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="check"] tag
+ *
+ *
+ * echo \Phalcon\Tag::checkField(array("terms", "value" => "Y"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function checkField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="radio"] tag
+ *
+ *
+ * echo \Phalcon\Tag::radioField(array("weather", "value" => "hot"))
+ *
+ *
+ * Volt syntax:
+ *
+ * {{ radio_field("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function radioField($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="image"] tag
+ *
+ *
+ * echo \Phalcon\Tag::imageInput(array("src" => "/img/button.png"));
+ *
+ *
+ * Volt syntax:
+ *
+ * {{ image_input("src": "/img/button.png") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function imageInput($parameters){ }
+
+
+ /**
+ * Builds a HTML input[type="submit"] tag
+ *
+ *
+ * echo \Phalcon\Tag::submitButton("Save")
+ *
+ *
+ * Volt syntax:
+ *
+ * {{ submit_button("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function submitButton($parameters){ }
+
+
+ /**
+ * Builds a HTML SELECT tag using a PHP array for options
+ *
+ *
+ * echo \Phalcon\Tag::selectStatic("status", array("A" => "Active", "I" => "Inactive"))
+ *
+ *
+ * @param array parameters
+ * @param array data
+ * @return string
+ */
+ public static function selectStatic($parameters, $data=null){ }
+
+
+ /**
+ * Builds a HTML SELECT tag using a \Phalcon\Mvc\Model resultset as options
+ *
+ *
+ * echo \Phalcon\Tag::select(array(
+ * "robotId",
+ * Robots::find("type = "mechanical""),
+ * "using" => array("id", "name")
+ * ));
+ *
+ *
+ * Volt syntax:
+ *
+ * {{ select("robotId", robots, "using": ["id", "name"]) }}
+ *
+ *
+ * @param array parameters
+ * @param array data
+ * @return string
+ */
+ public static function select($parameters, $data=null){ }
+
+
+ /**
+ * Builds a HTML TEXTAREA tag
+ *
+ *
+ * echo \Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4))
+ *
+ *
+ * Volt syntax:
+ *
+ * {{ text_area("comments", "cols": 10, "rows": 4) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function textArea($parameters){ }
+
+
+ /**
+ * Builds a HTML FORM tag
+ *
+ *
+ * echo \Phalcon\Tag::form("posts/save");
+ * echo \Phalcon\Tag::form(array("posts/save", "method" => "post"));
+ *
+ *
+ * Volt syntax:
+ *
+ * {{ form("posts/save") }}
+ * {{ form("posts/save", "method": "post") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ */
+ public static function form($parameters){ }
+
+
+ /**
+ * Builds a HTML close FORM tag
+ */
+ public static function endForm(){ }
+
+
+ /**
+ * Set the title of view content
+ *
+ *
+ * \Phalcon\Tag::setTitle("Welcome to my Page");
+ *
+ */
+ public static function setTitle($title){ }
+
+
+ /**
+ * Set the title separator of view content
+ *
+ *
+ * \Phalcon\Tag::setTitleSeparator("-");
+ *
+ */
+ public static function setTitleSeparator($titleSeparator){ }
+
+
+ /**
+ * Appends a text to current document title
+ */
+ public static function appendTitle($title){ }
+
+
+ /**
+ * Prepends a text to current document title
+ */
+ public static function prependTitle($title){ }
+
+
+ /**
+ * Gets the current document title
+ *
+ *
+ * echo \Phalcon\Tag::getTitle();
+ *
+ *
+ *
+ * {{ get_title() }}
+ *
+ */
+ public static function getTitle($tags=null){ }
+
+
+ /**
+ * Gets the current document title separator
+ *
+ *
+ * echo \Phalcon\Tag::getTitleSeparator();
+ *
+ *
+ *
+ * {{ get_title_separator() }}
+ *
+ */
+ public static function getTitleSeparator(){ }
+
+
+ /**
+ * Builds a LINK[rel="stylesheet"] tag
+ *
+ *
+ * echo \Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
+ * echo \Phalcon\Tag::stylesheetLink("css/style.css");
+ *
+ *
+ * Volt Syntax:
+ *
+ * {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }}
+ * {{ stylesheet_link("css/style.css") }}
+ *
+ *
+ * @param array parameters
+ * @param boolean local
+ * @return string
+ */
+ public static function stylesheetLink($parameters=null, $local=null){ }
+
+
+ /**
+ * Builds a SCRIPT[type="javascript"] tag
+ *
+ *
+ * echo \Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false);
+ * echo \Phalcon\Tag::javascriptInclude("javascript/jquery.js");
+ *
+ *
+ * Volt syntax:
+ *
+ * {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false) }}
+ * {{ javascript_include("javascript/jquery.js") }}
+ *
+ *
+ * @param array parameters
+ * @param boolean local
+ * @return string
+ */
+ public static function javascriptInclude($parameters=null, $local=null){ }
+
+
+ /**
+ * Builds HTML IMG tags
+ *
+ *
+ * echo \Phalcon\Tag::image("img/bg.png");
+ * echo \Phalcon\Tag::image(array("img/photo.jpg", "alt" => "Some Photo"));
+ *
+ *
+ * Volt Syntax:
+ *
+ * {{ image("img/bg.png") }}
+ * {{ image("img/photo.jpg", "alt": "Some Photo") }}
+ * {{ image("http://static.mywebsite.com/img/bg.png", false) }}
+ *
+ *
+ * @param array parameters
+ * @param boolean local
+ * @return string
+ */
+ public static function image($parameters=null, $local=null){ }
+
+
+ /**
+ * Converts texts into URL-friendly titles
+ *
+ *
+ * echo \Phalcon\Tag::friendlyTitle("These are big important news", "-")
+ *
+ *
+ * @param string text
+ * @param string separator
+ * @param boolean lowercase
+ * @param mixed replace
+ * @return text
+ */
+ public static function friendlyTitle($text, $separator=null, $lowercase=null, $replace=null){ }
+
+
+ /**
+ * Set the document type of content
+ */
+ public static function setDocType($doctype){ }
+
+
+ /**
+ * Get the document type declaration of content
+ */
+ public static function getDocType(){ }
+
+
+ /**
+ * Builds a HTML tag
+ *
+ *
+ * echo \Phalcon\Tag::tagHtml(name, parameters, selfClose, onlyStart, eol);
+ *
+ *
+ * @param string tagName
+ * @param array parameters
+ * @param boolean selfClose
+ * @param boolean onlyStart
+ * @param boolean useEol
+ * @return string
+ */
+ public static function tagHtml($tagName, $parameters=null, $selfClose=null, $onlyStart=null, $useEol=null){ }
+
+
+ /**
+ * Builds a HTML tag closing tag
+ *
+ *
+ * echo \Phalcon\Tag::tagHtmlClose("script", true)
+ *
+ */
+ public static function tagHtmlClose($tagName, $useEol=null){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Tag/Exception.php b/ide/2.0.2/Phalcon/Tag/Exception.php
new file mode 100644
index 000000000..bf66543e1
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Tag/Exception.php
@@ -0,0 +1,7 @@
+
+ * echo \Phalcon\Text::camelize('coco_bongo'); //CocoBongo
+ *
+ */
+ public static function camelize($str){ }
+
+
+ /**
+ * Uncamelize strings which are camelized
+ *
+ *
+ * echo \Phalcon\Text::camelize('CocoBongo'); //coco_bongo
+ *
+ */
+ public static function uncamelize($str){ }
+
+
+ /**
+ * Adds a number to a string or increment that number if it already is defined
+ *
+ *
+ * echo \Phalcon\Text::increment("a"); // "a_1"
+ * echo \Phalcon\Text::increment("a_1"); // "a_2"
+ *
+ */
+ public static function increment($str, $separator=null){ }
+
+
+ /**
+ * Generates a random string based on the given type. Type is one of the RANDOM_* constants
+ *
+ *
+ * echo \Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz"
+ *
+ */
+ public static function random($type=null, $length=null){ }
+
+
+ /**
+ * Check if a string starts with a given string
+ *
+ *
+ * echo \Phalcon\Text::startsWith("Hello", "He"); // true
+ * echo \Phalcon\Text::startsWith("Hello", "he", false); // false
+ * echo \Phalcon\Text::startsWith("Hello", "he"); // true
+ *
+ */
+ public static function startsWith($str, $start, $ignoreCase=null){ }
+
+
+ /**
+ * Check if a string ends with a given string
+ *
+ *
+ * echo \Phalcon\Text::endsWith("Hello", "llo"); // true
+ * echo \Phalcon\Text::endsWith("Hello", "LLO", false); // false
+ * echo \Phalcon\Text::endsWith("Hello", "LLO"); // true
+ *
+ */
+ public static function endsWith($str, $end, $ignoreCase=null){ }
+
+
+ /**
+ * Lowercases a string, this function makes use of the mbstring extension if available
+ *
+ *
+ * echo \Phalcon\Text::lower("HELLO"); // hello
+ *
+ */
+ public static function lower($str, $encoding=null){ }
+
+
+ /**
+ * Uppercases a string, this function makes use of the mbstring extension if available
+ *
+ *
+ * echo \Phalcon\Text::upper("hello"); // HELLO
+ *
+ */
+ public static function upper($str, $encoding=null){ }
+
+
+ /**
+ * Reduces multiple slashes in a string to single slashes
+ *
+ *
+ * echo \Phalcon\Text::reduceSlashes("foo//bar/baz"); // foo/bar/baz
+ * echo \Phalcon\Text::reduceSlashes("http://foo.bar///baz/buz"); // http://foo.bar/baz/buz
+ *
+ */
+ public static function reduceSlashes($str){ }
+
+
+ /**
+ * Concatenates strings using the separator only once without duplication in places concatenation
+ *
+ *
+ * $str = \Phalcon\Text::concat("/", "/tmp/", "/folder_1/", "/folder_2", "folder_3/");
+ * echo $str; // /tmp/folder_1/folder_2/folder_3/
+ *
+ *
+ * @param string separator
+ * @param string a
+ * @param string b
+ * @param string ...N
+ */
+ public static function concat(){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Translate.php b/ide/2.0.2/Phalcon/Translate.php
new file mode 100644
index 000000000..7b5b34a6c
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Translate.php
@@ -0,0 +1,7 @@
+
+ * print_r($messages[0]);
+ *
+ *
+ * @param int index
+ * @return \Phalcon\Validation\Message
+ */
+ public function offsetGet($index){ }
+
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ *
+ * $messages[0] = new \Phalcon\Validation\Message('This is a message');
+ *
+ *
+ * @param int index
+ * @param \Phalcon\Validation\Message message
+ */
+ public function offsetSet($index, $message){ }
+
+
+ /**
+ * Checks if an index exists
+ *
+ *
+ * var_dump(isset($message['database']));
+ *
+ *
+ * @param int index
+ * @return boolean
+ */
+ public function offsetExists($index){ }
+
+
+ /**
+ * Removes a message from the list
+ *
+ *
+ * unset($message['database']);
+ *
+ *
+ * @param string index
+ */
+ public function offsetUnset($index){ }
+
+
+ /**
+ * Appends a message to the group
+ *
+ *
+ * $messages->appendMessage(new \Phalcon\Validation\Message('This is a message'));
+ *
+ */
+ public function appendMessage(\Phalcon\Validation\MessageInterface $message){ }
+
+
+ /**
+ * Appends an array of messages to the group
+ *
+ *
+ * $messages->appendMessages($messagesArray);
+ *
+ *
+ * @param \Phalcon\Validation\MessageInterface[] messages
+ */
+ public function appendMessages($messages){ }
+
+
+ /**
+ * Filters the message group by field name
+ *
+ * @param string fieldName
+ * @return array
+ */
+ public function filter($fieldName){ }
+
+
+ /**
+ * Returns the number of messages in the list
+ */
+ public function count(){ }
+
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind(){ }
+
+
+ /**
+ * Returns the current message in the iterator
+ *
+ * @return \Phalcon\Validation\Message
+ */
+ public function current(){ }
+
+
+ /**
+ * Returns the current position/key in the iterator
+ */
+ public function key(){ }
+
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next(){ }
+
+
+ /**
+ * Check if the current message in the iterator is valid
+ */
+ public function valid(){ }
+
+
+ /**
+ * Magic __set_state helps to re-build messages variable when exporting
+ *
+ * @param array group
+ * @return \Phalcon\Validation\Message\Group
+ */
+ public static function __set_state($group){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/MessageInterface.php b/ide/2.0.2/Phalcon/Validation/MessageInterface.php
new file mode 100644
index 000000000..b5f172c83
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/MessageInterface.php
@@ -0,0 +1,34 @@
+
+ *use Phalcon\Validation\Validator\Alnum as AlnumValidator;
+ *
+ *$validator->add('username', new AlnumValidator(array(
+ * 'message' => ':field must contain only alphanumeric characters'
+ *)));
+ *
+ */
+
+ class Alnum extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Alpha.php b/ide/2.0.2/Phalcon/Validation/Validator/Alpha.php
new file mode 100644
index 000000000..d6ef87cc0
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Alpha.php
@@ -0,0 +1,27 @@
+
+ *use Phalcon\Validation\Validator\Alpha as AlphaValidator;
+ *
+ *$validator->add('username', new AlphaValidator(array(
+ * 'message' => ':field must contain only letters'
+ *)));
+ *
+ */
+
+ class Alpha extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Between.php b/ide/2.0.2/Phalcon/Validation/Validator/Between.php
new file mode 100644
index 000000000..b2f458ef2
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Between.php
@@ -0,0 +1,30 @@
+
+ *use Phalcon\Validation\Validator\Between;
+ *
+ *validator->add('name', new Between(array(
+ * 'minimum' => 0,
+ * 'maximum' => 100,
+ * 'message' => 'The price must be between 0 and 100'
+ *)));
+ *
+ */
+
+ class Between extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Confirmation.php b/ide/2.0.2/Phalcon/Validation/Validator/Confirmation.php
new file mode 100644
index 000000000..88bed4fe1
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Confirmation.php
@@ -0,0 +1,34 @@
+
+ *use Phalcon\Validation\Validator\Confirmation;
+ *
+ *$validator->add('password', new Confirmation(array(
+ * 'message' => 'Password doesn\'t match confirmation',
+ * 'with' => 'confirmPassword'
+ *)));
+ *
+ */
+
+ class Confirmation extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+
+ /**
+ * Compare strings
+ */
+ protected function compare($a, $b){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Digit.php b/ide/2.0.2/Phalcon/Validation/Validator/Digit.php
new file mode 100644
index 000000000..7a1dbc239
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Digit.php
@@ -0,0 +1,27 @@
+
+ *use Phalcon\Validation\Validator\Digit as DigitValidator;
+ *
+ *$validator->add('height', new DigitValidator(array(
+ * 'message' => ':field must be numeric'
+ *)));
+ *
+ */
+
+ class Digit extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Email.php b/ide/2.0.2/Phalcon/Validation/Validator/Email.php
new file mode 100644
index 000000000..57c578502
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Email.php
@@ -0,0 +1,27 @@
+
+ *use Phalcon\Validation\Validator\Email as EmailValidator;
+ *
+ *$validator->add('email', new EmailValidator(array(
+ * 'message' => 'The e-mail is not valid'
+ *)));
+ *
+ */
+
+ class Email extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/ExclusionIn.php b/ide/2.0.2/Phalcon/Validation/Validator/ExclusionIn.php
new file mode 100644
index 000000000..c8259d363
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/ExclusionIn.php
@@ -0,0 +1,28 @@
+
+ *use Phalcon\Validation\Validator\ExclusionIn;
+ *
+ *$validator->add('status', new ExclusionIn(array(
+ * 'message' => 'The status must not be A or B',
+ * 'domain' => array('A', 'B')
+ *)));
+ *
+ */
+
+ class ExclusionIn extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/File.php b/ide/2.0.2/Phalcon/Validation/Validator/File.php
new file mode 100644
index 000000000..043539ef5
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/File.php
@@ -0,0 +1,32 @@
+
+ *use Phalcon\Validation\Validator\File as FileValidator;
+ *
+ *$validator->add('file', new FileValidator(array(
+ * 'maxSize' => '2M',
+ * 'messageSize' => ':field exceeds the max filesize (:max)',
+ * 'allowedTypes' => array('image/jpeg', 'image/png'),
+ * 'messageType' => 'Allowed file types are :types',
+ * 'maxResolution' => '800x600',
+ * 'messageMaxResolution' => 'Max resolution of :field is :max'
+ *)));
+ *
+ */
+
+ class File extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Identical.php b/ide/2.0.2/Phalcon/Validation/Validator/Identical.php
new file mode 100644
index 000000000..d16aed133
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Identical.php
@@ -0,0 +1,29 @@
+
+ *use Phalcon\Validation\Validator\Identical;
+ *
+ *$validator->add('terms', new Identical(array(
+ * 'accepted' => 'yes',
+ * 'message' => 'Terms and conditions must be accepted'
+ *)));
+ *
+ *
+ */
+
+ class Identical extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/InclusionIn.php b/ide/2.0.2/Phalcon/Validation/Validator/InclusionIn.php
new file mode 100644
index 000000000..2645a1cb8
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/InclusionIn.php
@@ -0,0 +1,28 @@
+
+ *use Phalcon\Validation\Validator\InclusionIn;
+ *
+ *$validator->add('status', new InclusionIn(array(
+ * 'message' => 'The status must be A or B',
+ * 'domain' => array('A', 'B')
+ *)));
+ *
+ */
+
+ class InclusionIn extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Numericality.php b/ide/2.0.2/Phalcon/Validation/Validator/Numericality.php
new file mode 100644
index 000000000..be497e4ab
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Numericality.php
@@ -0,0 +1,27 @@
+
+ *use Phalcon\Validation\Validator\Numericality;
+ *
+ *$validator->add('price', new Numericality(array(
+ * 'message' => ':field is not numeric'
+ *)));
+ *
+ */
+
+ class Numericality extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/PresenceOf.php b/ide/2.0.2/Phalcon/Validation/Validator/PresenceOf.php
new file mode 100644
index 000000000..a5b9af689
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/PresenceOf.php
@@ -0,0 +1,27 @@
+
+ *use Phalcon\Validation\Validator\PresenceOf;
+ *
+ *$validator->add('name', new PresenceOf(array(
+ * 'message' => 'The name is required'
+ *)));
+ *
+ */
+
+ class PresenceOf extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Regex.php b/ide/2.0.2/Phalcon/Validation/Validator/Regex.php
new file mode 100644
index 000000000..64f01bd8a
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Regex.php
@@ -0,0 +1,28 @@
+
+ *use Phalcon\Validation\Validator\Regex as RegexValidator;
+ *
+ *$validator->add('created_at', new RegexValidator(array(
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/',
+ * 'message' => 'The creation date is invalid'
+ *)));
+ *
+ */
+
+ class Regex extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/StringLength.php b/ide/2.0.2/Phalcon/Validation/Validator/StringLength.php
new file mode 100644
index 000000000..0307f7279
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/StringLength.php
@@ -0,0 +1,33 @@
+
+ *use Phalcon\Validation\Validator\StringLength as StringLength;
+ *
+ *$validation->add('name_last', new StringLength(array(
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ *)));
+ *
+ *
+ */
+
+ class StringLength extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Uniqueness.php b/ide/2.0.2/Phalcon/Validation/Validator/Uniqueness.php
new file mode 100644
index 000000000..632553f44
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Uniqueness.php
@@ -0,0 +1,36 @@
+
+ *use Phalcon\Validation\Validator\Uniqueness as UniquenessValidator;
+ *
+ *$validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'message' => ':field must be unique'
+ *)));
+ *
+ *
+ * Different attribute from the field
+ *
+ *$validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'attribute' => 'nick'
+ *)));
+ *
+ */
+
+ class Uniqueness extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/Validator/Url.php b/ide/2.0.2/Phalcon/Validation/Validator/Url.php
new file mode 100644
index 000000000..2a8add802
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/Validator/Url.php
@@ -0,0 +1,27 @@
+
+ *use Phalcon\Validation\Validator\Url as UrlValidator;
+ *
+ *$validator->add('url', new UrlValidator(array(
+ * 'message' => ':field must be a url'
+ *)));
+ *
+ */
+
+ class Url extends \Phalcon\Validation\Validator implements \Phalcon\Validation\ValidatorInterface {
+
+ /**
+ * Executes the validation
+ */
+ public function validate(\Phalcon\Validation $validation, $field){ }
+
+ }
+}
diff --git a/ide/2.0.2/Phalcon/Validation/ValidatorInterface.php b/ide/2.0.2/Phalcon/Validation/ValidatorInterface.php
new file mode 100644
index 000000000..9cfb24ed6
--- /dev/null
+++ b/ide/2.0.2/Phalcon/Validation/ValidatorInterface.php
@@ -0,0 +1,19 @@
+
+ * echo \Phalcon\Version::get();
+ *
+ */
+ public static function get(){ }
+
+
+ /**
+ * Returns the numeric active version
+ *
+ *
+ * echo \Phalcon\Version::getId();
+ *
+ */
+ public static function getId(){ }
+
+
+ /**
+ * Returns a specific part of the version. If the wrong parameter is passed
+ * it will return the full version
+ *
+ *
+ * echo \Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ */
+ public static function getPart($part){ }
+
+ }
+}
diff --git a/ide/2.0.3/Phalcon/Acl.php b/ide/2.0.3/Phalcon/Acl.php
new file mode 100644
index 000000000..54a8d3549
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Acl.php
@@ -0,0 +1,45 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * //Default action is deny access
+ * $acl->setDefaultAction(\Phalcon\Acl::DENY);
+ * //Create some roles
+ * $roleAdmins = new \Phalcon\Acl\Role('Administrators', 'Super-User role');
+ * $roleGuests = new \Phalcon\Acl\Role('Guests');
+ * //Add "Guests" role to acl
+ * $acl->addRole($roleGuests);
+ * //Add "Designers" role to acl
+ * $acl->addRole('Designers');
+ * //Define the "Customers" resource
+ * $customersResource = new \Phalcon\Acl\Resource('Customers', 'Customers management');
+ * //Add "customers" resource with a couple of operations
+ * $acl->addResource($customersResource, 'search');
+ * $acl->addResource($customersResource, array('create', 'update'));
+ * //Set access level for roles into resources
+ * $acl->allow('Guests', 'Customers', 'search');
+ * $acl->allow('Guests', 'Customers', 'create');
+ * $acl->deny('Guests', 'Customers', 'update');
+ * //Check whether role has access to the operations
+ * $acl->isAllowed('Guests', 'Customers', 'edit'); //Returns 0
+ * $acl->isAllowed('Guests', 'Customers', 'search'); //Returns 1
+ * $acl->isAllowed('Guests', 'Customers', 'create'); //Returns 1
+ *
+ */
+abstract class Acl
+{
+
+ const ALLOW = 1;
+
+
+ const DENY = 0;
+
+
+}
diff --git a/ide/2.0.3/Phalcon/Config.php b/ide/2.0.3/Phalcon/Config.php
new file mode 100644
index 000000000..b3112b0da
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Config.php
@@ -0,0 +1,145 @@
+
+ * $config = new \Phalcon\Config(array(
+ * "database" => array(
+ * "adapter" => "Mysql",
+ * "host" => "localhost",
+ * "username" => "scott",
+ * "password" => "cheetah",
+ * "dbname" => "test_db"
+ * ),
+ * "phalcon" => array(
+ * "controllersDir" => "../app/controllers/",
+ * "modelsDir" => "../app/models/",
+ * "viewsDir" => "../app/views/"
+ * )
+ * ));
+ *
+ */
+class Config implements \ArrayAccess, \Countable
+{
+
+ /**
+ * Phalcon\Config constructor
+ *
+ * @param array $arrayConfig
+ */
+ public function __construct($arrayConfig = null) {}
+
+ /**
+ * Allows to check whether an attribute is defined using the array-syntax
+ *
+ * var_dump(isset($config['database']));
+ *
+ *
+ * @param mixed $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets an attribute from the configuration, if the attribute isn't defined returns null
+ * If the value is exactly null or is not defined the default value will be used instead
+ *
+ * echo $config->get('controllersDir', '../app/controllers/');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $defaultValue
+ */
+ public function get($index, $defaultValue = null) {}
+
+ /**
+ * Gets an attribute using the array-syntax
+ *
+ * print_r($config['database']);
+ *
+ *
+ * @param mixed $index
+ * @return string
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $config['database'] = array('type' => 'Sqlite');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Unsets an attribute using the array-syntax
+ *
+ * unset($config['database']);
+ *
+ *
+ * @param mixed $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Merges a configuration into the current one
+ *
+ * $appConfig = new \Phalcon\Config(array('database' => array('host' => 'localhost')));
+ * $globalConfig->merge($config2);
+ *
+ *
+ * @param mixed $config
+ * @return Config
+ */
+ public function merge(Config $config) {}
+
+ /**
+ * Converts recursively the object to an array
+ *
+ * print_r($config->toArray());
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Returns the count of properties set in the config
+ *
+ * print count($config);
+ *
+ * or
+ *
+ * print $config->count();
+ *
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Restores the state of a Phalcon\Config object
+ *
+ * @param array $data
+ * @return Config
+ */
+ public static function __set_state($data) {}
+
+ /**
+ * Helper method for merge configs (forwarding nested config instance)
+ *
+ * @param Config $config
+ * @param Config $instance = null
+ * @return Config config
+ */
+ protected final function _merge(Config $config, $instance = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/Crypt.php b/ide/2.0.3/Phalcon/Crypt.php
new file mode 100644
index 000000000..7ff497474
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Crypt.php
@@ -0,0 +1,194 @@
+
+ * $crypt = new \Phalcon\Crypt();
+ * $key = 'le password';
+ * $text = 'This is a secret text';
+ * $encrypted = $crypt->encrypt($text, $key);
+ * echo $crypt->decrypt($encrypted, $key);
+ *
+ */
+class Crypt implements \Phalcon\CryptInterface
+{
+
+ const PADDING_DEFAULT = 0;
+
+
+ const PADDING_ANSI_X_923 = 1;
+
+
+ const PADDING_PKCS7 = 2;
+
+
+ const PADDING_ISO_10126 = 3;
+
+
+ const PADDING_ISO_IEC_7816_4 = 4;
+
+
+ const PADDING_ZERO = 5;
+
+
+ const PADDING_SPACE = 6;
+
+
+ protected $_key;
+
+
+ protected $_padding = 0;
+
+
+ protected $_mode = "cbc";
+
+
+ protected $_cipher = "rijndael-256";
+
+
+ /**
+ * @brief Phalcon\CryptInterface Phalcon\Crypt::setPadding(int $scheme)
+ * @param int $scheme Padding scheme
+ * @return \Phalcon\CryptInterface
+ */
+ public function setPadding($scheme) {}
+
+ /**
+ * Sets the cipher algorithm
+ *
+ * @param string $cipher
+ * @return Crypt
+ */
+ public function setCipher($cipher) {}
+
+ /**
+ * Returns the current cipher
+ *
+ * @return string
+ */
+ public function getCipher() {}
+
+ /**
+ * Sets the encrypt/decrypt mode
+ *
+ * @param string $mode
+ * @return Crypt
+ */
+ public function setMode($mode) {}
+
+ /**
+ * Returns the current encryption mode
+ *
+ * @return string
+ */
+ public function getMode() {}
+
+ /**
+ * Sets the encryption key
+ *
+ * @param string $key
+ * @return Crypt
+ */
+ public function setKey($key) {}
+
+ /**
+ * Returns the encryption key
+ *
+ * @return string
+ */
+ public function getKey() {}
+
+ /**
+ * Adds padding @a padding_type to @a text
+ *
+ * @see http://www.di-mgt.com.au/cryptopad.html
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ * @param return_value $Result, possibly padded
+ * @param text $Message to be padded
+ * @param mode $Encryption mode; padding is applied only in CBC or ECB mode
+ * @param block_size $Cipher block size
+ * @param padding_type $Padding scheme
+ */
+ protected function _cryptPadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Removes padding @a padding_type from @a text
+ * If the function detects that the text was not padded, it will return it unmodified
+ *
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ * @param return_value $Result, possibly unpadded
+ * @param text $Message to be unpadded
+ * @param mode $Encryption mode; unpadding is applied only in CBC or ECB mode
+ * @param block_size $Cipher block size
+ * @param padding_type $Padding scheme
+ */
+ protected function _cryptUnpadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Encrypts a text
+ *
+ * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
+ *
+ *
+ * @param string $text
+ * @param string $key
+ * @return string
+ */
+ public function encrypt($text, $key = null) {}
+
+ /**
+ * Decrypts an encrypted text
+ *
+ * echo $crypt->decrypt($encrypted, "decrypt password");
+ *
+ *
+ * @param string $text
+ * @param mixed $key
+ * @return string
+ */
+ public function decrypt($text, $key = null) {}
+
+ /**
+ * Encrypts a text returning the result as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function encryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Decrypt a text that is coded as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function decryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Returns a list of available cyphers
+ *
+ * @return array
+ */
+ public function getAvailableCiphers() {}
+
+ /**
+ * Returns a list of available modes
+ *
+ * @return array
+ */
+ public function getAvailableModes() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/CryptInterface.php b/ide/2.0.3/Phalcon/CryptInterface.php
new file mode 100644
index 000000000..529103de4
--- /dev/null
+++ b/ide/2.0.3/Phalcon/CryptInterface.php
@@ -0,0 +1,107 @@
+
+ * try {
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306',
+ * ));
+ * $result = $connection->query("SELECTFROM robots LIMIT 5");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetch()) {
+ * print_r($robot);
+ * }
+ * } catch (Phalcon\Db\Exception $e) {
+ * echo $e->getMessage(), PHP_EOL;
+ * }
+ *
+ */
+abstract class Db
+{
+
+ const FETCH_LAZY = 1;
+
+
+ const FETCH_ASSOC = 2;
+
+
+ const FETCH_NAMED = 11;
+
+
+ const FETCH_NUM = 3;
+
+
+ const FETCH_BOTH = 4;
+
+
+ const FETCH_OBJ = 5;
+
+
+ const FETCH_BOUND = 6;
+
+
+ const FETCH_COLUMN = 7;
+
+
+ const FETCH_CLASS = 8;
+
+
+ const FETCH_INTO = 9;
+
+
+ const FETCH_FUNC = 10;
+
+
+ const FETCH_GROUP = 65536;
+
+
+ const FETCH_UNIQUE = 196608;
+
+
+ const FETCH_KEY_PAIR = 12;
+
+
+ const FETCH_CLASSTYPE = 262144;
+
+
+ const FETCH_SERIALIZE = 524288;
+
+
+ const FETCH_PROPS_LATE = 1048576;
+
+
+ /**
+ * Enables/disables options in the Database component
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/Debug.php b/ide/2.0.3/Phalcon/Debug.php
new file mode 100644
index 000000000..ab342395c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Debug.php
@@ -0,0 +1,192 @@
+
+ * $di = new \Phalcon\Di();
+ * //Using a string definition
+ * $di->set("request", "Phalcon\Http\Request", true);
+ * //Using an anonymous function
+ * $di->set("request", function(){
+ * return new \Phalcon\Http\Request();
+ * }, true);
+ * $request = $di->getRequest();
+ *
+ */
+class Di implements \Phalcon\DiInterface
+{
+ /**
+ * List of registered services
+ */
+ protected $_services;
+
+ /**
+ * List of shared instances
+ */
+ protected $_sharedInstances;
+
+ /**
+ * To know if the latest resolved instance was shared or not
+ */
+ protected $_freshInstance = false;
+
+ /**
+ * Events Manager
+ *
+ * @var \Phalcon\Events\ManagerInterface
+ */
+ protected $_eventsManager;
+
+ /**
+ * Latest DI build
+ */
+ static protected $_default;
+
+
+ /**
+ * Phalcon\Di constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the internal event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setInternalEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getInternalEventsManager() {}
+
+ /**
+ * Registers a service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function set($name, $definition, $shared = false) {}
+
+ /**
+ * Registers an "always shared" service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setShared($name, $definition) {}
+
+ /**
+ * Removes a service in the services container
+ *
+ * @param string $name
+ */
+ public function remove($name) {}
+
+ /**
+ * Attempts to register a service in the services container
+ * Only is successful if a service hasn"t been registered previously
+ * with the same name
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return bool|\Phalcon\Di\ServiceInterface
+ */
+ public function attempt($name, $definition, $shared = false) {}
+
+ /**
+ * Sets a service using a raw Phalcon\Di\Service definition
+ *
+ * @param string $name
+ * @param mixed $rawDefinition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setRaw($name, \Phalcon\Di\ServiceInterface $rawDefinition) {}
+
+ /**
+ * Returns a service definition without resolving
+ *
+ * @param string $name
+ */
+ public function getRaw($name) {}
+
+ /**
+ * Returns a Phalcon\Di\Service instance
+ *
+ * @param string $name
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function getService($name) {}
+
+ /**
+ * Resolves the service based on its configuration
+ *
+ * @param string $name
+ * @param mixed $parameters
+ */
+ public function get($name, $parameters = null) {}
+
+ /**
+ * Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
+ *
+ * @param string $name
+ * @param array $parameters
+ * @return mixed
+ */
+ public function getShared($name, $parameters = null) {}
+
+ /**
+ * Check whether the DI contains a service by a name
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Check whether the last service obtained via getShared produced a fresh instance or an existing one
+ *
+ * @return bool
+ */
+ public function wasFreshInstance() {}
+
+ /**
+ * Return the services registered in the DI
+ *
+ * @return \Phalcon\Di\Service
+ */
+ public function getServices() {}
+
+ /**
+ * Check if a service is registered using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetExists($name) {}
+
+ /**
+ * Allows to register a shared service using the array syntax
+ *
+ * $di["request"] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return boolean
+ */
+ public function offsetSet($name, $definition) {}
+
+ /**
+ * Allows to obtain a shared service using the array syntax
+ *
+ * var_dump($di["request"]);
+ *
+ *
+ * @param string $name
+ * @return mixed
+ */
+ public function offsetGet($name) {}
+
+ /**
+ * Removes a service from the services container using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetUnset($name) {}
+
+ /**
+ * Magic method to get or set services using setters/getters
+ *
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ public function __call($method, $arguments = null) {}
+
+ /**
+ * Set a default dependency injection container to be obtained into static methods
+ *
+ * @param mixed $dependencyInjector
+ */
+ public static function setDefault(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Return the lastest DI created
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public static function getDefault() {}
+
+ /**
+ * Resets the internal default DI
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/DiInterface.php b/ide/2.0.3/Phalcon/DiInterface.php
new file mode 100644
index 000000000..65bae52fe
--- /dev/null
+++ b/ide/2.0.3/Phalcon/DiInterface.php
@@ -0,0 +1,134 @@
+
+ * $this->dispatcher->forward(array("controller" => "posts", "action" => "index"));
+ *
+ *
+ * @param array $forward
+ */
+ public function forward($forward) {}
+
+ /**
+ * Check if the current executed action was forwarded by another one
+ *
+ * @return bool
+ */
+ public function wasForwarded() {}
+
+ /**
+ * Possible class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getHandlerClass() {}
+
+ /**
+ * Set empty properties to their defaults (where defaults are available)
+ */
+ protected function _resolveEmptyProperties() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/DispatcherInterface.php b/ide/2.0.3/Phalcon/DispatcherInterface.php
new file mode 100644
index 000000000..1b5a292cc
--- /dev/null
+++ b/ide/2.0.3/Phalcon/DispatcherInterface.php
@@ -0,0 +1,120 @@
+
+ * $escaper = new \Phalcon\Escaper();
+ * $escaped = $escaper->escapeCss("font-family:
+ * $escaper->setEncoding('utf-8');
+ *
+ *
+ * @param string $encoding
+ */
+ public function setEncoding($encoding) {}
+
+ /**
+ * Returns the internal encoding used by the escaper
+ *
+ * @return string
+ */
+ public function getEncoding() {}
+
+ /**
+ * Sets the HTML quoting type for htmlspecialchars
+ *
+ * $escaper->setHtmlQuoteType(ENT_XHTML);
+ *
+ *
+ * @param int $quoteType
+ */
+ public function setHtmlQuoteType($quoteType) {}
+
+ /**
+ * Detect the character encoding of a string to be handled by an encoder
+ * Special-handling for chr(172) and chr(128) to chr(159) which fail to be detected by mb_detect_encoding()
+ *
+ * @param string $str
+ * @return string|null
+ */
+ public final function detectEncoding($str) {}
+
+ /**
+ * Utility to normalize a string's encoding to UTF-32.
+ *
+ * @param string $str
+ * @return string
+ */
+ public final function normalizeEncoding($str) {}
+
+ /**
+ * Escapes a HTML string. Internally uses htmlspecialchars
+ *
+ * @param string $text
+ * @return string
+ */
+ public function escapeHtml($text) {}
+
+ /**
+ * Escapes a HTML attribute string
+ *
+ * @param string $attribute
+ * @return string
+ */
+ public function escapeHtmlAttr($attribute) {}
+
+ /**
+ * Escape CSS strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $css
+ * @return string
+ */
+ public function escapeCss($css) {}
+
+ /**
+ * Escape javascript strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $js
+ * @return string
+ */
+ public function escapeJs($js) {}
+
+ /**
+ * Escapes a URL. Internally uses rawurlencode
+ *
+ * @param string $url
+ * @return string
+ */
+ public function escapeUrl($url) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/EscaperInterface.php b/ide/2.0.3/Phalcon/EscaperInterface.php
new file mode 100644
index 000000000..e8718dea2
--- /dev/null
+++ b/ide/2.0.3/Phalcon/EscaperInterface.php
@@ -0,0 +1,73 @@
+
+ * $filter = new \Phalcon\Filter();
+ * $filter->sanitize("some(one)@exa\\mple.com", "email"); // returns "someone@example.com"
+ * $filter->sanitize("hello<<", "string"); // returns "hello"
+ * $filter->sanitize("!100a019", "int"); // returns "100019"
+ * $filter->sanitize("!100a019.01a", "float"); // returns "100019.01"
+ *
+ */
+class Filter implements \Phalcon\FilterInterface
+{
+
+ const FILTER_EMAIL = "email";
+
+
+ const FILTER_ABSINT = "absint";
+
+
+ const FILTER_INT = "int";
+
+
+ const FILTER_INT_CAST = "int!";
+
+
+ const FILTER_STRING = "string";
+
+
+ const FILTER_FLOAT = "float";
+
+
+ const FILTER_FLOAT_CAST = "float!";
+
+
+ const FILTER_ALPHANUM = "alphanum";
+
+
+ const FILTER_TRIM = "trim";
+
+
+ const FILTER_STRIPTAGS = "striptags";
+
+
+ const FILTER_LOWER = "lower";
+
+
+ const FILTER_UPPER = "upper";
+
+
+ protected $_filters;
+
+
+ /**
+ * Adds a user-defined filter
+ *
+ * @param string $name
+ * @param mixed $handler
+ * @return Filter
+ */
+ public function add($name, $handler) {}
+
+ /**
+ * Sanitizes a value with a specified single or set of filters
+ *
+ * @param mixed $value
+ * @param mixed $filters
+ * @param bool $noRecursive
+ */
+ public function sanitize($value, $filters, $noRecursive = false) {}
+
+ /**
+ * Internal sanitize wrapper to filter_var
+ *
+ * @param mixed $value
+ * @param string $filter
+ */
+ protected function _sanitize($value, $filter) {}
+
+ /**
+ * Return the user-defined filters in the instance
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/FilterInterface.php b/ide/2.0.3/Phalcon/FilterInterface.php
new file mode 100644
index 000000000..5ebd2ee21
--- /dev/null
+++ b/ide/2.0.3/Phalcon/FilterInterface.php
@@ -0,0 +1,37 @@
+
+ * $flash->success("The record was successfully deleted");
+ * $flash->error("Cannot open the file");
+ *
+ */
+abstract class Flash
+{
+
+ protected $_cssClasses;
+
+
+ protected $_implicitFlush = true;
+
+
+ protected $_automaticHtml = true;
+
+
+ /**
+ * Phalcon\Flash constructor
+ *
+ * @param mixed $cssClasses
+ */
+ public function __construct($cssClasses = null) {}
+
+ /**
+ * Set whether the output must be implicitly flushed to the output or returned as string
+ *
+ * @param bool $implicitFlush
+ * @return \Phalcon\FlashInterface
+ */
+ public function setImplicitFlush($implicitFlush) {}
+
+ /**
+ * Set if the output must be implicitly formatted with HTML
+ *
+ * @param bool $automaticHtml
+ * @return \Phalcon\FlashInterface
+ */
+ public function setAutomaticHtml($automaticHtml) {}
+
+ /**
+ * Set an array with CSS classes to format the messages
+ *
+ * @param array $cssClasses
+ * @return \Phalcon\FlashInterface
+ */
+ public function setCssClasses($cssClasses) {}
+
+ /**
+ * Shows a HTML error message
+ *
+ * $flash->error('This is an error');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function error($message) {}
+
+ /**
+ * Shows a HTML notice/information message
+ *
+ * $flash->notice('This is an information');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function notice($message) {}
+
+ /**
+ * Shows a HTML success message
+ *
+ * $flash->success('The process was finished successfully');
+ *
+ *
+ * @param string $message
+ * @return string
+ */
+ public function success($message) {}
+
+ /**
+ * Shows a HTML warning message
+ *
+ * $flash->warning('Hey, this is important');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function warning($message) {}
+
+ /**
+ * Outputs a message formatting it with HTML
+ *
+ * $flash->outputMessage('error', message);
+ *
+ *
+ * @param string $type
+ * @param string|array $message
+ */
+ public function outputMessage($type, $message) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/FlashInterface.php b/ide/2.0.3/Phalcon/FlashInterface.php
new file mode 100644
index 000000000..86ca19753
--- /dev/null
+++ b/ide/2.0.3/Phalcon/FlashInterface.php
@@ -0,0 +1,48 @@
+
+ * //Creates the autoloader
+ * $loader = new Loader();
+ * //Register some namespaces
+ * $loader->registerNamespaces(array(
+ * 'Example\Base' => 'vendor/example/base/',
+ * 'Example\Adapter' => 'vendor/example/adapter/',
+ * 'Example' => 'vendor/example/'
+ * ));
+ * //register autoloader
+ * $loader->register();
+ * //Requiring this class will automatically include file vendor/example/adapter/Some.php
+ * $adapter = Example\Adapter\Some();
+ *
+ */
+class Loader implements \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_eventsManager = null;
+
+
+ protected $_foundPath = null;
+
+
+ protected $_checkedPath = null;
+
+
+ protected $_prefixes = null;
+
+
+ protected $_classes = null;
+
+
+ protected $_extensions;
+
+
+ protected $_namespaces = null;
+
+
+ protected $_directories = null;
+
+
+ protected $_registered = false;
+
+
+ /**
+ * Phalcon\Loader constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the events manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets an array of file extensions that the loader must try in each attempt to locate the file
+ *
+ * @param array $extensions
+ * @return Loader
+ */
+ public function setExtensions($extensions) {}
+
+ /**
+ * Returns the file extensions registered in the loader
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register namespaces and their related directories
+ *
+ * @param array $namespaces
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerNamespaces($namespaces, $merge = false) {}
+
+ /**
+ * Returns the namespaces currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getNamespaces() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $prefixes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerPrefixes($prefixes, $merge = false) {}
+
+ /**
+ * Returns the prefixes currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getPrefixes() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $directories
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerDirs($directories, $merge = false) {}
+
+ /**
+ * Returns the directories currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getDirs() {}
+
+ /**
+ * Register classes and their locations
+ *
+ * @param array $classes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerClasses($classes, $merge = false) {}
+
+ /**
+ * Returns the class-map currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getClasses() {}
+
+ /**
+ * Register the autoload method
+ *
+ * @return Loader
+ */
+ public function register() {}
+
+ /**
+ * Unregister the autoload method
+ *
+ * @return Loader
+ */
+ public function unregister() {}
+
+ /**
+ * Autoloads the registered classes
+ *
+ * @param string $className
+ * @return bool
+ */
+ public function autoLoad($className) {}
+
+ /**
+ * Get the path when a class was found
+ *
+ * @return string
+ */
+ public function getFoundPath() {}
+
+ /**
+ * Get the path the loader is checking for a path
+ *
+ * @return string
+ */
+ public function getCheckedPath() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/Logger.php b/ide/2.0.3/Phalcon/Logger.php
new file mode 100644
index 000000000..6ea41067c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Logger.php
@@ -0,0 +1,53 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+abstract class Logger
+{
+
+ const SPECIAL = 9;
+
+
+ const CUSTOM = 8;
+
+
+ const DEBUG = 7;
+
+
+ const INFO = 6;
+
+
+ const NOTICE = 5;
+
+
+ const WARNING = 4;
+
+
+ const ERROR = 3;
+
+
+ const ALERT = 2;
+
+
+ const CRITICAL = 1;
+
+
+ const EMERGENCE = 0;
+
+
+ const EMERGENCY = 0;
+
+
+}
diff --git a/ide/2.0.3/Phalcon/Registry.php b/ide/2.0.3/Phalcon/Registry.php
new file mode 100644
index 000000000..560353724
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Registry.php
@@ -0,0 +1,150 @@
+
+ * $registry = new \Phalcon\Registry();
+ * // Set value
+ * $registry->something = 'something';
+ * // or
+ * $registry['something'] = 'something';
+ * // Get value
+ * $value = $registry->something;
+ * // or
+ * $value = $registry['something'];
+ * // Check if the key exists
+ * $exists = isset($registry->something);
+ * // or
+ * $exists = isset($registry['something']);
+ * // Unset
+ * unset($registry->something);
+ * // or
+ * unset($registry['something']);
+ *
+ * In addition to ArrayAccess, Phalcon\Registry also implements Countable
+ * (count($registry) will return the number of elements in the registry),
+ * Serializable and Iterator (you can iterate over the registry
+ * using a foreach loop) interfaces. For PHP 5.4 and higher, JsonSerializable
+ * interface is implemented.
+ * Phalcon\Registry is very fast (it is typically faster than any userspace
+ * implementation of the registry); however, this comes at a price:
+ * Phalcon\Registry is a final class and cannot be inherited from.
+ * Though Phalcon\Registry exposes methods like __get(), offsetGet(), count() etc,
+ * it is not recommended to invoke them manually (these methods exist mainly to
+ * match the interfaces the registry implements): $registry->__get('property')
+ * is several times slower than $registry->property.
+ * Internally all the magic methods (and interfaces except JsonSerializable)
+ * are implemented using object handlers or similar techniques: this allows
+ * to bypass relatively slow method calls.
+ */
+final class Registry implements \ArrayAccess, \Countable, \Iterator
+{
+
+ protected $_data;
+
+
+ /**
+ * Registry constructor
+ */
+ public final function __construct() {}
+
+ /**
+ * Checks if the element is present in the registry
+ *
+ * @param string $offset
+ * @return bool
+ */
+ public final function offsetExists($offset) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $offset
+ * @return variable
+ */
+ public final function offsetGet($offset) {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $offset
+ * @param mixed $value
+ */
+ public final function offsetSet($offset, $value) {}
+
+ /**
+ * Unsets an element in the registry
+ *
+ * @param string $offset
+ */
+ public final function offsetUnset($offset) {}
+
+ /**
+ * Checks how many elements are in the register
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Moves cursor to next row in the registry
+ */
+ public final function next() {}
+
+ /**
+ * Gets pointer number of active row in the registry
+ *
+ * @return int
+ */
+ public final function key() {}
+
+ /**
+ * Rewinds the registry cursor to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Checks if the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Obtains the current value in the internal iterator
+ */
+ public function current() {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public final function __set($key, $value) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $key
+ * @return variable
+ */
+ public final function __get($key) {}
+
+ /**
+ * @param string $key
+ * @return bool
+ */
+ public final function __isset($key) {}
+
+ /**
+ * @param string $key
+ */
+ public final function __unset($key) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/Security.php b/ide/2.0.3/Phalcon/Security.php
new file mode 100644
index 000000000..0a44a9e35
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Security.php
@@ -0,0 +1,201 @@
+
+ * $login = $this->request->getPost('login');
+ * $password = $this->request->getPost('password');
+ * $user = Users::findFirstByLogin($login);
+ * if ($user) {
+ * if ($this->security->checkHash($password, $user->password)) {
+ * //The password is valid
+ * }
+ * }
+ *
+ */
+class Security implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const CRYPT_DEFAULT = 0;
+
+
+ const CRYPT_STD_DES = 1;
+
+
+ const CRYPT_EXT_DES = 2;
+
+
+ const CRYPT_MD5 = 3;
+
+
+ const CRYPT_BLOWFISH = 4;
+
+
+ const CRYPT_BLOWFISH_X = 5;
+
+
+ const CRYPT_BLOWFISH_Y = 6;
+
+
+ const CRYPT_SHA256 = 7;
+
+
+ const CRYPT_SHA512 = 8;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_workFactor = 8;
+
+
+ protected $_numberBytes = 16;
+
+
+ protected $_tokenKeySessionID = "$PHALCON/CSRF/KEY$";
+
+
+ protected $_tokenValueSessionID = "$PHALCON/CSRF$";
+
+
+ protected $_csrf;
+
+
+ protected $_defaultHash;
+
+
+ /**
+ * @param mixed $workFactor
+ */
+ public function setWorkFactor($workFactor) {}
+
+
+ public function getWorkFactor() {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @param long $randomBytes
+ */
+ public function setRandomBytes($randomBytes) {}
+
+ /**
+ * Returns a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @return string
+ */
+ public function getRandomBytes() {}
+
+ /**
+ * Generate a >22-length pseudo random string to be used as salt for passwords
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getSaltBytes($numberBytes = 0) {}
+
+ /**
+ * Creates a password hash using bcrypt with a pseudo random salt
+ *
+ * @param string $password
+ * @param int $workFactor
+ * @return string
+ */
+ public function hash($password, $workFactor = 0) {}
+
+ /**
+ * Checks a plain text password and its hash version to check if the password matches
+ *
+ * @param string $password
+ * @param string $passwordHash
+ * @param int $maxPassLength
+ * @return bool
+ */
+ public function checkHash($password, $passwordHash, $maxPassLength = 0) {}
+
+ /**
+ * Checks if a password hash is a valid bcrypt's hash
+ *
+ * @param string $passwordHash
+ * @return bool
+ */
+ public function isLegacyHash($passwordHash) {}
+
+ /**
+ * Generates a pseudo random token key to be used as input's name in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getTokenKey($numberBytes = null) {}
+
+ /**
+ * Generates a pseudo random token value to be used as input's value in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getToken($numberBytes = null) {}
+
+ /**
+ * Check if the CSRF token sent in the request is the same that the current in session
+ *
+ * @param mixed $tokenKey
+ * @param mixed $tokenValue
+ * @param bool $destroyIfValid
+ * @return bool
+ */
+ public function checkToken($tokenKey = null, $tokenValue = null, $destroyIfValid = true) {}
+
+ /**
+ * Returns the value of the CSRF token in session
+ *
+ * @return string
+ */
+ public function getSessionToken() {}
+
+ /**
+ * Removes the value of the CSRF token and key from session
+ */
+ public function destroyToken() {}
+
+ /**
+ * Computes a HMAC
+ *
+ * @param string $data
+ * @param string $key
+ * @param string $algo
+ * @param boolean $raw
+ */
+ public function computeHmac($data, $key, $algo, $raw = false) {}
+
+ /**
+ * Sets the default hash
+ *
+ * @param mixed $defaultHash
+ */
+ public function setDefaultHash($defaultHash) {}
+
+ /**
+ * Sets the default hash
+ */
+ public function getDefaultHash() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/Session.php b/ide/2.0.3/Phalcon/Session.php
new file mode 100644
index 000000000..76e72cff4
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Session.php
@@ -0,0 +1,23 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+abstract class Session
+{
+
+}
diff --git a/ide/2.0.3/Phalcon/Tag.php b/ide/2.0.3/Phalcon/Tag.php
new file mode 100644
index 000000000..ee232b3b2
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Tag.php
@@ -0,0 +1,718 @@
+
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefault("name", "peter");
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function setDefault($id, $value) {}
+
+ /**
+ * Assigns default values to generated tags by helpers
+ *
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefaults(array("name" => "peter"));
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param array $values
+ * @param bool $merge
+ */
+ public static function setDefaults($values, $merge = false) {}
+
+ /**
+ * Alias of Phalcon\Tag::setDefault
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function displayTo($id, $value) {}
+
+ /**
+ * Check if a helper has a default value set using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @return boolean
+ */
+ public static function hasValue($name) {}
+
+ /**
+ * Every helper calls this function to check whether a component has a predefined
+ * value using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @param array $params
+ * @return mixed
+ */
+ public static function getValue($name, $params = null) {}
+
+ /**
+ * Resets the request and internal values to avoid those fields will have any default value
+ */
+ public static function resetInput() {}
+
+ /**
+ * Builds a HTML A tag using framework conventions
+ *
+ * echo Phalcon\Tag::linkTo("signup/register", "Register Here!");
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!"));
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!", "class" => "btn-primary"));
+ * echo Phalcon\Tag::linkTo("http://phalconphp.com/", "Phalcon", FALSE);
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", FALSE));
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", "local" =>FALSE));
+ *
+ *
+ * @param array|string $parameters
+ * @param string $text
+ * @param boolean $local
+ * @return string
+ */
+ public static function linkTo($parameters, $text = null, $local = true) {}
+
+ /**
+ * Builds generic INPUT tags
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @param bool $asValue
+ * @param $boolean asValue
+ * @return string
+ */
+ static protected final function _inputField($type, $parameters, $asValue = false) {}
+
+ /**
+ * Builds INPUT tags that implements the checked attribute
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @return string
+ */
+ static protected final function _inputFieldChecked($type, $parameters) {}
+
+ /**
+ * Builds a HTML input[type="color"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function colorField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="text"] tag
+ *
+ * echo Phalcon\Tag::textField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="number"] tag
+ *
+ * echo Phalcon\Tag::numericField(array("price", "min" => "1", "max" => "5"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function numericField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="range"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function rangeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="email"] tag
+ *
+ * echo Phalcon\Tag::emailField("email");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function emailField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="date"] tag
+ *
+ * echo Phalcon\Tag::dateField(array("born", "value" => "14-12-1980"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function dateField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime-local"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeLocalField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="month"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function monthField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="time"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function timeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="week"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function weekField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="password"] tag
+ *
+ * echo Phalcon\Tag::passwordField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function passwordField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="hidden"] tag
+ *
+ * echo Phalcon\Tag::hiddenField(array("name", "value" => "mike"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function hiddenField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="file"] tag
+ *
+ * echo Phalcon\Tag::fileField("file");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function fileField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="search"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function searchField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="tel"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function telField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="url"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function urlField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="check"] tag
+ *
+ * echo Phalcon\Tag::checkField(array("terms", "value" => "Y"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function checkField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="radio"] tag
+ *
+ * echo Phalcon\Tag::radioField(array("weather", "value" => "hot"))
+ *
+ * Volt syntax:
+ *
+ * {{ radio_field("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function radioField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="image"] tag
+ *
+ * echo Phalcon\Tag::imageInput(array("src" => "/img/button.png"));
+ *
+ * Volt syntax:
+ *
+ * {{ image_input("src": "/img/button.png") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function imageInput($parameters) {}
+
+ /**
+ * Builds a HTML input[type="submit"] tag
+ *
+ * echo Phalcon\Tag::submitButton("Save")
+ *
+ * Volt syntax:
+ *
+ * {{ submit_button("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function submitButton($parameters) {}
+
+ /**
+ * Builds a HTML SELECT tag using a PHP array for options
+ *
+ * echo Phalcon\Tag::selectStatic("status", array("A" => "Active", "I" => "Inactive"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function selectStatic($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML SELECT tag using a Phalcon\Mvc\Model resultset as options
+ *
+ * echo Phalcon\Tag::select(array(
+ * "robotId",
+ * Robots::find("type = "mechanical""),
+ * "using" => array("id", "name")
+ * ));
+ *
+ * Volt syntax:
+ *
+ * {{ select("robotId", robots, "using": ["id", "name"]) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function select($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML TEXTAREA tag
+ *
+ * echo Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4))
+ *
+ * Volt syntax:
+ *
+ * {{ text_area("comments", "cols": 10, "rows": 4) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textArea($parameters) {}
+
+ /**
+ * Builds a HTML FORM tag
+ *
+ * echo Phalcon\Tag::form("posts/save");
+ * echo Phalcon\Tag::form(array("posts/save", "method" => "post"));
+ *
+ * Volt syntax:
+ *
+ * {{ form("posts/save") }}
+ * {{ form("posts/save", "method": "post") }}
+ *
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function form($parameters) {}
+
+ /**
+ * Builds a HTML close FORM tag
+ *
+ * @return string
+ */
+ public static function endForm() {}
+
+ /**
+ * Set the title of view content
+ *
+ * Phalcon\Tag::setTitle("Welcome to my Page");
+ *
+ *
+ * @param string $title
+ */
+ public static function setTitle($title) {}
+
+ /**
+ * Set the title separator of view content
+ *
+ * Phalcon\Tag::setTitleSeparator("-");
+ *
+ *
+ * @param string $titleSeparator
+ */
+ public static function setTitleSeparator($titleSeparator) {}
+
+ /**
+ * Appends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function appendTitle($title) {}
+
+ /**
+ * Prepends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function prependTitle($title) {}
+
+ /**
+ * Gets the current document title
+ *
+ * echo Phalcon\Tag::getTitle();
+ *
+ *
+ * {{ get_title() }}
+ *
+ *
+ * @param bool $tags
+ * @return string
+ */
+ public static function getTitle($tags = true) {}
+
+ /**
+ * Gets the current document title separator
+ *
+ * echo Phalcon\Tag::getTitleSeparator();
+ *
+ *
+ * {{ get_title_separator() }}
+ *
+ *
+ * @return string
+ */
+ public static function getTitleSeparator() {}
+
+ /**
+ * Builds a LINK[rel="stylesheet"] tag
+ *
+ * echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
+ * echo Phalcon\Tag::stylesheetLink("css/style.css");
+ *
+ * Volt Syntax:
+ *
+ * {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }}
+ * {{ stylesheet_link("css/style.css") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function stylesheetLink($parameters = null, $local = true) {}
+
+ /**
+ * Builds a SCRIPT[type="javascript"] tag
+ *
+ * echo Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false);
+ * echo Phalcon\Tag::javascriptInclude("javascript/jquery.js");
+ *
+ * Volt syntax:
+ *
+ * {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false) }}
+ * {{ javascript_include("javascript/jquery.js") }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function javascriptInclude($parameters = null, $local = true) {}
+
+ /**
+ * Builds HTML IMG tags
+ *
+ * echo Phalcon\Tag::image("img/bg.png");
+ * echo Phalcon\Tag::image(array("img/photo.jpg", "alt" => "Some Photo"));
+ *
+ * Volt Syntax:
+ *
+ * {{ image("img/bg.png") }}
+ * {{ image("img/photo.jpg", "alt": "Some Photo") }}
+ * {{ image("http://static.mywebsite.com/img/bg.png", false) }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function image($parameters = null, $local = true) {}
+
+ /**
+ * Converts texts into URL-friendly titles
+ *
+ * echo Phalcon\Tag::friendlyTitle("These are big important news", "-")
+ *
+ *
+ * @param string $text
+ * @param string $separator
+ * @param boolean $lowercase
+ * @param mixed $replace
+ * @return text
+ */
+ public static function friendlyTitle($text, $separator = "-", $lowercase = true, $replace = null) {}
+
+ /**
+ * Set the document type of content
+ *
+ * @param int $doctype
+ */
+ public static function setDocType($doctype) {}
+
+ /**
+ * Get the document type declaration of content
+ *
+ * @return string
+ */
+ public static function getDocType() {}
+
+ /**
+ * Builds a HTML tag
+ *
+ * echo Phalcon\Tag::tagHtml(name, parameters, selfClose, onlyStart, eol);
+ *
+ *
+ * @param string $tagName
+ * @param array $parameters
+ * @param boolean $selfClose
+ * @param boolean $onlyStart
+ * @param boolean $useEol
+ * @return string
+ */
+ public static function tagHtml($tagName, $parameters = null, $selfClose = false, $onlyStart = false, $useEol = false) {}
+
+ /**
+ * Builds a HTML tag closing tag
+ *
+ * echo Phalcon\Tag::tagHtmlClose("script", true)
+ *
+ *
+ * @param string $tagName
+ * @param bool $useEol
+ * @return string
+ */
+ public static function tagHtmlClose($tagName, $useEol = false) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/Text.php b/ide/2.0.3/Phalcon/Text.php
new file mode 100644
index 000000000..4e394ee89
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Text.php
@@ -0,0 +1,155 @@
+
+ * echo Phalcon\Text::camelize('coco_bongo'); //CocoBongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function camelize($str) {}
+
+ /**
+ * Uncamelize strings which are camelized
+ *
+ * echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function uncamelize($str) {}
+
+ /**
+ * Adds a number to a string or increment that number if it already is defined
+ *
+ * echo Phalcon\Text::increment("a"); // "a_1"
+ * echo Phalcon\Text::increment("a_1"); // "a_2"
+ *
+ *
+ * @param string $str
+ * @param mixed $separator
+ * @return string
+ */
+ public static function increment($str, $separator = null) {}
+
+ /**
+ * Generates a random string based on the given type. Type is one of the RANDOM_* constants
+ *
+ * echo Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz"
+ *
+ *
+ * @param int $type
+ * @param long $length
+ * @return string
+ */
+ public static function random($type = 0, $length = 8) {}
+
+ /**
+ * Check if a string starts with a given string
+ *
+ * echo Phalcon\Text::startsWith("Hello", "He"); // true
+ * echo Phalcon\Text::startsWith("Hello", "he", false); // false
+ * echo Phalcon\Text::startsWith("Hello", "he"); // true
+ *
+ *
+ * @param string $str
+ * @param string $start
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function startsWith($str, $start, $ignoreCase = true) {}
+
+ /**
+ * Check if a string ends with a given string
+ *
+ * echo Phalcon\Text::endsWith("Hello", "llo"); // true
+ * echo Phalcon\Text::endsWith("Hello", "LLO", false); // false
+ * echo Phalcon\Text::endsWith("Hello", "LLO"); // true
+ *
+ *
+ * @param string $str
+ * @param string $end
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function endsWith($str, $end, $ignoreCase = true) {}
+
+ /**
+ * Lowercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::lower("HELLO"); // hello
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function lower($str, $encoding = "UTF-8") {}
+
+ /**
+ * Uppercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::upper("hello"); // HELLO
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function upper($str, $encoding = "UTF-8") {}
+
+ /**
+ * Reduces multiple slashes in a string to single slashes
+ *
+ * echo Phalcon\Text::reduceSlashes("foo//bar/baz"); // foo/bar/baz
+ * echo Phalcon\Text::reduceSlashes("http://foo.bar///baz/buz"); // http://foo.bar/baz/buz
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function reduceSlashes($str) {}
+
+ /**
+ * Concatenates strings using the separator only once without duplication in places concatenation
+ *
+ * $str = Phalcon\Text::concat("/", "/tmp/", "/folder_1/", "/folder_2", "folder_3/");
+ * echo $str; // /tmp/folder_1/folder_2/folder_3/
+ *
+ *
+ * @param string $separator
+ * @param string $a
+ * @param string $b
+ * @param string $...N
+ * @return string
+ */
+ public static function concat() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/Translate.php b/ide/2.0.3/Phalcon/Translate.php
new file mode 100644
index 000000000..e0cf39581
--- /dev/null
+++ b/ide/2.0.3/Phalcon/Translate.php
@@ -0,0 +1,13 @@
+
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ */
+ const VERSION_MAJOR = 0;
+
+ /**
+ * The constant referencing the major version. Returns 1
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MEDIUM);
+ *
+ */
+ const VERSION_MEDIUM = 1;
+
+ /**
+ * The constant referencing the major version. Returns 2
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MINOR);
+ *
+ */
+ const VERSION_MINOR = 2;
+
+ /**
+ * The constant referencing the major version. Returns 3
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL);
+ *
+ */
+ const VERSION_SPECIAL = 3;
+
+ /**
+ * The constant referencing the major version. Returns 4
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL_NUMBER);
+ *
+ */
+ const VERSION_SPECIAL_NUMBER = 4;
+
+
+ /**
+ * Area where the version number is set. The format is as follows:
+ * ABBCCDE
+ * A - Major version
+ * B - Med version (two digits)
+ * C - Min version (two digits)
+ * D - Special release: 1 = Alpha, 2 = Beta, 3 = RC, 4 = Stable
+ * E - Special release version i.e. RC1, Beta2 etc.
+ *
+ * @return array
+ */
+ protected static function _getVersion() {}
+
+ /**
+ * Translates a number to a special release
+ * If Special release = 1 this function will return ALPHA
+ *
+ * @param int $special
+ * @return string
+ */
+ protected final static function _getSpecial($special) {}
+
+ /**
+ * Returns the active version (string)
+ *
+ * echo Phalcon\Version::get();
+ *
+ *
+ * @return string
+ */
+ public static function get() {}
+
+ /**
+ * Returns the numeric active version
+ *
+ * echo Phalcon\Version::getId();
+ *
+ *
+ * @return string
+ */
+ public static function getId() {}
+
+ /**
+ * Returns a specific part of the version. If the wrong parameter is passed
+ * it will return the full version
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ *
+ * @param int $part
+ * @return string
+ */
+ public static function getPart($part) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/acl/Adapter.php b/ide/2.0.3/Phalcon/acl/Adapter.php
new file mode 100644
index 000000000..d261e1917
--- /dev/null
+++ b/ide/2.0.3/Phalcon/acl/Adapter.php
@@ -0,0 +1,103 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * $acl->setDefaultAction(Phalcon\Acl::DENY);
+ * //Register roles
+ * $roles = array(
+ * 'users' => new \Phalcon\Acl\Role('Users'),
+ * 'guests' => new \Phalcon\Acl\Role('Guests')
+ * );
+ * foreach ($roles as $role) {
+ * $acl->addRole($role);
+ * }
+ * //Private area resources
+ * $privateResources = array(
+ * 'companies' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'products' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'invoices' => array('index', 'profile')
+ * );
+ * foreach ($privateResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Public area resources
+ * $publicResources = array(
+ * 'index' => array('index'),
+ * 'about' => array('index'),
+ * 'session' => array('index', 'register', 'start', 'end'),
+ * 'contact' => array('index', 'send')
+ * );
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Grant access to public areas to both users and guests
+ * foreach ($roles as $role){
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->allow($role->getName(), $resource, '*');
+ * }
+ * }
+ * //Grant access to private area to role Users
+ * foreach ($privateResources as $resource => $actions) {
+ * foreach ($actions as $action) {
+ * $acl->allow('Users', $resource, $action);
+ * }
+ * }
+ *
+ */
+class Memory extends \Phalcon\Acl\Adapter
+{
+ /**
+ * Roles Names
+ *
+ * @var mixed
+ */
+ protected $_rolesNames;
+
+ /**
+ * Roles
+ *
+ * @var mixed
+ */
+ protected $_roles;
+
+ /**
+ * Resource Names
+ *
+ * @var mixed
+ */
+ protected $_resourcesNames;
+
+ /**
+ * Resources
+ *
+ * @var mixed
+ */
+ protected $_resources;
+
+ /**
+ * Access
+ *
+ * @var mixed
+ */
+ protected $_access;
+
+ /**
+ * Role Inherits
+ *
+ * @var mixed
+ */
+ protected $_roleInherits;
+
+ /**
+ * Access List
+ *
+ * @var mixed
+ */
+ protected $_accessList;
+
+
+ /**
+ * Phalcon\Acl\Adapter\Memory constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Adds a role to the ACL list. Second parameter allows inheriting access data from other existing role
+ * Example:
+ *
+ * $acl->addRole(new Phalcon\Acl\Role('administrator'), 'consultant');
+ * $acl->addRole('administrator', 'consultant');
+ *
+ *
+ * @param mixed $role
+ * @param array|string $accessInherits
+ * @return bool
+ */
+ public function addRole($role, $accessInherits = null) {}
+
+ /**
+ * Do a role inherit from another existing role
+ *
+ * @param string $roleName
+ * @param mixed $roleToInherit
+ * @return bool
+ */
+ public function addInherit($roleName, $roleToInherit) {}
+
+ /**
+ * Check whether role exist in the roles list
+ *
+ * @param string $roleName
+ * @return bool
+ */
+ public function isRole($roleName) {}
+
+ /**
+ * Check whether resource exist in the resources list
+ *
+ * @param string $resourceName
+ * @return bool
+ */
+ public function isResource($resourceName) {}
+
+ /**
+ * Adds a resource to the ACL list
+ * Access names can be a particular action, by example
+ * search, update, delete, etc or a list of them
+ * Example:
+ *
+ * //Add a resource to the the list allowing access to an action
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), 'search');
+ * $acl->addResource('customers', 'search');
+ * //Add a resource with an access list
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), array('create', 'search'));
+ * $acl->addResource('customers', array('create', 'search'));
+ *
+ *
+ * @param \Phalcon\Acl\Resource|string $resourceValue
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResource($resourceValue, $accessList) {}
+
+ /**
+ * Adds access to resources
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Removes an access from a resource
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ */
+ public function dropResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Checks if a role has access to a resource
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ * @param mixed $action
+ */
+ protected function _allowOrDeny($roleName, $resourceName, $access, $action) {}
+
+ /**
+ * Allow access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Allow access to guests to search on customers
+ * $acl->allow('guests', 'customers', 'search');
+ * //Allow access to guests to search or create on customers
+ * $acl->allow('guests', 'customers', array('search', 'create'));
+ * //Allow access to any role to browse on products
+ * $acl->allow('*', 'products', 'browse');
+ * //Allow access to any role to browse on any resource
+ * $acl->allow('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function allow($roleName, $resourceName, $access) {}
+
+ /**
+ * Deny access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Deny access to guests to search on customers
+ * $acl->deny('guests', 'customers', 'search');
+ * //Deny access to guests to search or create on customers
+ * $acl->deny('guests', 'customers', array('search', 'create'));
+ * //Deny access to any role to browse on products
+ * $acl->deny('*', 'products', 'browse');
+ * //Deny access to any role to browse on any resource
+ * $acl->deny('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function deny($roleName, $resourceName, $access) {}
+
+ /**
+ * Check whether a role is allowed to access an action from a resource
+ *
+ * //Does andres have access to the customers resource to create?
+ * $acl->isAllowed('andres', 'Products', 'create');
+ * //Do guests have access to any resource to edit?
+ * $acl->isAllowed('guests', '*', 'edit');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param string $access
+ * @return bool
+ */
+ public function isAllowed($roleName, $resourceName, $access) {}
+
+ /**
+ * Return an array with every role registered in the list
+ *
+ * @return \Phalcon\Acl\Role
+ */
+ public function getRoles() {}
+
+ /**
+ * Return an array with every resource registered in the list
+ *
+ * @return \Phalcon\Acl\Resource
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/annotations/Adapter.php b/ide/2.0.3/Phalcon/annotations/Adapter.php
new file mode 100644
index 000000000..19b67c0aa
--- /dev/null
+++ b/ide/2.0.3/Phalcon/annotations/Adapter.php
@@ -0,0 +1,74 @@
+
+ * //Traverse annotations
+ * foreach ($classAnnotations as $annotation) {
+ * echo 'Name=', $annotation->getName(), PHP_EOL;
+ * }
+ * //Check if the annotations has a specific
+ * var_dump($classAnnotations->has('Cacheable'));
+ * //Get an specific annotation in the collection
+ * $annotation = $classAnnotations->get('Cacheable');
+ *
+ */
+class Collection implements \Iterator, \Countable
+{
+
+ protected $_position = 0;
+
+
+ protected $_annotations;
+
+
+ /**
+ * Phalcon\Annotations\Collection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the number of annotations in the collection
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current annotation in the iterator
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current annotation in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Returns the internal annotations as an array
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAnnotations() {}
+
+ /**
+ * Returns the first annotation that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function get($name) {}
+
+ /**
+ * Returns all the annotations that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAll($name) {}
+
+ /**
+ * Check if an annotation exists in a collection
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/annotations/Exception.php b/ide/2.0.3/Phalcon/annotations/Exception.php
new file mode 100644
index 000000000..973db2530
--- /dev/null
+++ b/ide/2.0.3/Phalcon/annotations/Exception.php
@@ -0,0 +1,9 @@
+
+ * //Parse the annotations in a class
+ * $reader = new \Phalcon\Annotations\Reader();
+ * $parsing = reader->parse('MyComponent');
+ * //Create the reflection
+ * $reflection = new \Phalcon\Annotations\Reflection($parsing);
+ * //Get the annotations in the class docblock
+ * $classAnnotations = reflection->getClassAnnotations();
+ *
+ */
+class Reflection
+{
+
+ protected $_reflectionData;
+
+
+ protected $_classAnnotations;
+
+
+ protected $_methodAnnotations;
+
+
+ protected $_propertyAnnotations;
+
+
+ /**
+ * Phalcon\Annotations\Reflection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the annotations found in the class docblock
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getClassAnnotations() {}
+
+ /**
+ * Returns the annotations found in the methods' docblocks
+ *
+ * @return \Phalcon\Annotations\Collection[]
+ */
+ public function getMethodsAnnotations() {}
+
+ /**
+ * Returns the annotations found in the properties' docblocks
+ *
+ * @return \Phalcon\Annotations\Collection[]
+ */
+ public function getPropertiesAnnotations() {}
+
+ /**
+ * Returns the raw parsing intermediate definitions used to construct the reflection
+ *
+ * @return array
+ */
+ public function getReflectionData() {}
+
+ /**
+ * Restores the state of a Phalcon\Annotations\Reflection variable export
+ *
+ * @param mixed $data
+ * @return array
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/annotations/adapter/Apc.php b/ide/2.0.3/Phalcon/annotations/adapter/Apc.php
new file mode 100644
index 000000000..822c0c8a8
--- /dev/null
+++ b/ide/2.0.3/Phalcon/annotations/adapter/Apc.php
@@ -0,0 +1,44 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Apc();
+ *
+ */
+class Apc extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from APC
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/annotations/adapter/Files.php b/ide/2.0.3/Phalcon/annotations/adapter/Files.php
new file mode 100644
index 000000000..9115c2b35
--- /dev/null
+++ b/ide/2.0.3/Phalcon/annotations/adapter/Files.php
@@ -0,0 +1,43 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Files(array(
+ * 'annotationsDir' => 'app/cache/annotations/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_annotationsDir = "./";
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from files
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to files
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/annotations/adapter/Memory.php b/ide/2.0.3/Phalcon/annotations/adapter/Memory.php
new file mode 100644
index 000000000..84ad80c8c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/annotations/adapter/Memory.php
@@ -0,0 +1,35 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Xcache();
+ *
+ */
+class Xcache extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ /**
+ * Reads parsed annotations from XCache
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to XCache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/assets/Collection.php b/ide/2.0.3/Phalcon/assets/Collection.php
new file mode 100644
index 000000000..b33b6eb08
--- /dev/null
+++ b/ide/2.0.3/Phalcon/assets/Collection.php
@@ -0,0 +1,271 @@
+
+ * $inline = new \Phalcon\Assets\Inline('js', 'alert("hello world");');
+ *
+ */
+class Inline
+{
+
+ protected $_type;
+
+
+ protected $_content;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+
+ public function getType() {}
+
+
+ public function getContent() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+ /**
+ * Phalcon\Assets\Inline constructor
+ *
+ * @param string $type
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $content, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the inline's type
+ *
+ * @param string $type
+ * @return Inline
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Inline
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Inline
+ */
+ public function setAttributes($attributes) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/assets/Manager.php b/ide/2.0.3/Phalcon/assets/Manager.php
new file mode 100644
index 000000000..05e744bc1
--- /dev/null
+++ b/ide/2.0.3/Phalcon/assets/Manager.php
@@ -0,0 +1,235 @@
+
+ * $assets->addCss('css/bootstrap.css');
+ * $assets->addCss('http://bootstrap.my-cdn.com/style.css', false);
+ *
+ *
+ * @param string $path
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addCss($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline Css to the 'css' collection
+ *
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addInlineCss($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a javascript resource to the 'js' collection
+ *
+ * $assets->addJs('scripts/jquery.js');
+ * $assets->addJs('http://jquery.my-cdn.com/jquery.js', false);
+ *
+ *
+ * @param string $path
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addJs($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline javascript to the 'js' collection
+ *
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+ */
+ public function addInlineJs($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a resource by its type
+ *
+ * $assets->addResourceByType('css', new \Phalcon\Assets\Resource\Css('css/style.css'));
+ *
+ *
+ * @param string $type
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResourceByType($type, \Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a inline code by its type
+ *
+ * @param string $type
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCodeByType($type, Inline $code) {}
+
+ /**
+ * Adds a raw resource to the manager
+ *
+ * $assets->addResource(new Phalcon\Assets\Resource('css', 'css/style.css'));
+ *
+ *
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResource(\Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a raw inline code to the manager
+ *
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCode(Inline $code) {}
+
+ /**
+ * Sets a collection in the Assets Manager
+ *
+ * $assets->set('js', $collection);
+ *
+ *
+ * @param string $id
+ * @param mixed $collection
+ * @return Manager
+ */
+ public function set($id, \Phalcon\Assets\Collection $collection) {}
+
+ /**
+ * Returns a collection by its id
+ *
+ * $scripts = $assets->get('js');
+ *
+ *
+ * @param string $id
+ * @return \Phalcon\Assets\Collection
+ */
+ public function get($id) {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getCss() {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getJs() {}
+
+ /**
+ * Creates/Returns a collection of resources
+ *
+ * @param string $name
+ * @return \Phalcon\Assets\Collection
+ */
+ public function collection($name) {}
+
+ /**
+ * Traverses a collection calling the callback to generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param callback $callback
+ * @param string $type
+ */
+ public function output(\Phalcon\Assets\Collection $collection, $callback, $type) {}
+
+ /**
+ * Traverses a collection and generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param string $type
+ */
+ public function outputInline(\Phalcon\Assets\Collection $collection, $type) {}
+
+ /**
+ * Prints the HTML for CSS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline CSS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for JS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputJs($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline JS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineJs($collectionName = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/assets/Resource.php b/ide/2.0.3/Phalcon/assets/Resource.php
new file mode 100644
index 000000000..e2013640d
--- /dev/null
+++ b/ide/2.0.3/Phalcon/assets/Resource.php
@@ -0,0 +1,170 @@
+
+ * $resource = new \Phalcon\Assets\Resource('js', 'javascripts/jquery.js');
+ *
+ */
+class Resource
+{
+
+ protected $_type;
+
+
+ protected $_path;
+
+
+ protected $_local;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+ protected $_sourcePath;
+
+
+ protected $_targetPath;
+
+
+ protected $_targetUri;
+
+
+
+ public function getType() {}
+
+
+ public function getPath() {}
+
+
+ public function getLocal() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+
+ public function getSourcePath() {}
+
+
+ public function getTargetPath() {}
+
+
+ public function getTargetUri() {}
+
+ /**
+ * Phalcon\Assets\Resource constructor
+ *
+ * @param string $type
+ * @param string $path
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the resource's type
+ *
+ * @param string $type
+ * @return Resource
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets the resource's path
+ *
+ * @param string $path
+ * @return Resource
+ */
+ public function setPath($path) {}
+
+ /**
+ * Sets if the resource is local or external
+ *
+ * @param bool $local
+ * @return Resource
+ */
+ public function setLocal($local) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Resource
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Resource
+ */
+ public function setAttributes($attributes) {}
+
+ /**
+ * Sets a target uri for the generated HTML
+ *
+ * @param string $targetUri
+ * @return Resource
+ */
+ public function setTargetUri($targetUri) {}
+
+ /**
+ * Sets the resource's source path
+ *
+ * @param string $sourcePath
+ * @return Resource
+ */
+ public function setSourcePath($sourcePath) {}
+
+ /**
+ * Sets the resource's target path
+ *
+ * @param string $targetPath
+ * @return Resource
+ */
+ public function setTargetPath($targetPath) {}
+
+ /**
+ * Returns the content of the resource as an string
+ * Optionally a base path where the resource is located can be set
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getContent($basePath = null) {}
+
+ /**
+ * Returns the real target uri for the generated HTML
+ *
+ * @return string
+ */
+ public function getRealTargetUri() {}
+
+ /**
+ * Returns the complete location where the resource is located
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealSourcePath($basePath = null) {}
+
+ /**
+ * Returns the complete location where the resource must be written
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealTargetPath($basePath = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/assets/filters/Cssmin.php b/ide/2.0.3/Phalcon/assets/filters/Cssmin.php
new file mode 100644
index 000000000..7071441f5
--- /dev/null
+++ b/ide/2.0.3/Phalcon/assets/filters/Cssmin.php
@@ -0,0 +1,22 @@
+
+ * use Phalcon\Cache\Frontend\Data as DataFrontend,
+ * Phalcon\Cache\Multiple,
+ * Phalcon\Cache\Backend\Apc as ApcCache,
+ * Phalcon\Cache\Backend\Memcache as MemcacheCache,
+ * Phalcon\Cache\Backend\File as FileCache;
+ * $ultraFastFrontend = new DataFrontend(array(
+ * "lifetime" => 3600
+ * ));
+ * $fastFrontend = new DataFrontend(array(
+ * "lifetime" => 86400
+ * ));
+ * $slowFrontend = new DataFrontend(array(
+ * "lifetime" => 604800
+ * ));
+ * //Backends are registered from the fastest to the slower
+ * $cache = new Multiple(array(
+ * new ApcCache($ultraFastFrontend, array(
+ * "prefix" => 'cache',
+ * )),
+ * new MemcacheCache($fastFrontend, array(
+ * "prefix" => 'cache',
+ * "host" => "localhost",
+ * "port" => "11211"
+ * )),
+ * new FileCache($slowFrontend, array(
+ * "prefix" => 'cache',
+ * "cacheDir" => "../app/cache/"
+ * ))
+ * ));
+ * //Save, saves in every backend
+ * $cache->save('my-key', $data);
+ *
+ */
+class Multiple
+{
+
+ protected $_backends;
+
+
+ /**
+ * Phalcon\Cache\Multiple constructor
+ *
+ * @param Phalcon\Cache\BackendInterface[] backends
+ * @param mixed $backends
+ */
+ public function __construct($backends = null) {}
+
+ /**
+ * Adds a backend
+ *
+ * @param mixed $backend
+ * @return Multiple
+ */
+ public function push(\Phalcon\Cache\BackendInterface $backend) {}
+
+ /**
+ * Returns a cached content reading the internal backends
+ *
+ * @param mixed $keyName
+ * @param long $lifetime
+ * @param $string|int keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Starts every backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ */
+ public function start($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into all backends and stops the frontend
+ *
+ * @param string $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = null) {}
+
+ /**
+ * Deletes a value from each backend
+ *
+ * @param string|int $keyName
+ * @return boolean
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Checks if cache exists in at least one backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/cache/backend/Apc.php b/ide/2.0.3/Phalcon/cache/backend/Apc.php
new file mode 100644
index 000000000..8e6f53d83
--- /dev/null
+++ b/ide/2.0.3/Phalcon/cache/backend/Apc.php
@@ -0,0 +1,95 @@
+
+ * //Cache data for 2 days
+ * $frontCache = new \Phalcon\Cache\Frontend\Data(array(
+ * 'lifetime' => 172800
+ * ));
+ * $cache = new \Phalcon\Cache\Backend\Apc($frontCache, array(
+ * 'prefix' => 'app-data'
+ * ));
+ * //Cache arbitrary data
+ * $cache->save('my-data', array(1, 2, 3, 4, 5));
+ * //Get data
+ * $data = $cache->get('my-data');
+ *
+ */
+class Apc extends \Phalcon\Cache\Backend implements \Phalcon\Cache\BackendInterface
+{
+
+ /**
+ * Returns a cached content
+ *
+ * @param string $keyName
+ * @param long $lifetime
+ * @param $string|long keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into the APC backend and stops the frontend
+ *
+ * @param string|long $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = true) {}
+
+ /**
+ * Increment of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function increment($keyName = null, $value = 1) {}
+
+ /**
+ * Decrement of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function decrement($keyName = null, $value = 1) {}
+
+ /**
+ * Deletes a value from the cache by its key
+ *
+ * @param string $keyName
+ * @return bool
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Query the existing cached keys
+ *
+ * @param string $prefix
+ * @return array
+ */
+ public function queryKeys($prefix = null) {}
+
+ /**
+ * Checks if cache exists and it hasn't expired
+ *
+ * @param string|long $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+ /**
+ * Immediately invalidates all existing items.
+ *
+ * @return bool
+ */
+ public function flush() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/cache/backend/File.php b/ide/2.0.3/Phalcon/cache/backend/File.php
new file mode 100644
index 000000000..44e4a87c0
--- /dev/null
+++ b/ide/2.0.3/Phalcon/cache/backend/File.php
@@ -0,0 +1,135 @@
+
+ * //Cache the file for 2 days
+ * $frontendOptions = array(
+ * 'lifetime' => 172800
+ * );
+ * //Create a output cache
+ * $frontCache = \Phalcon\Cache\Frontend\Output($frontOptions);
+ * //Set the cache directory
+ * $backendOptions = array(
+ * 'cacheDir' => '../app/cache/'
+ * );
+ * //Create the File backend
+ * $cache = new \Phalcon\Cache\Backend\File($frontCache, $backendOptions);
+ * $content = $cache->start('my-cache');
+ * if ($content === null) {
+ * echo '
+ * application->addModules(array(
+ * 'admin' => array(
+ * 'className' => 'Multiple\Admin\Module',
+ * 'path' => '../apps/admin/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ */
+ public function addModules($modules) {}
+
+ /**
+ * Return the modules registered in the console
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Handle the whole command-line tasks
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Set an specific argument
+ *
+ * @param array $arguments
+ * @param bool $str
+ * @param bool $shift
+ * @return Console
+ */
+ public function setArgument($arguments = null, $str = true, $shift = true) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/cli/Dispatcher.php b/ide/2.0.3/Phalcon/cli/Dispatcher.php
new file mode 100644
index 000000000..9af6c4e3f
--- /dev/null
+++ b/ide/2.0.3/Phalcon/cli/Dispatcher.php
@@ -0,0 +1,111 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Cli\Dispatcher();
+ * $dispatcher->setDi(di);
+ * $dispatcher->setTaskName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $handle = dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher
+{
+
+ protected $_handlerSuffix = "Task";
+
+
+ protected $_defaultHandler = "main";
+
+
+ protected $_defaultAction = "main";
+
+
+ protected $_options;
+
+
+ /**
+ * Phalcon\Cli\Dispatcher constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the default task suffix
+ *
+ * @param string $taskSuffix
+ */
+ public function setTaskSuffix($taskSuffix) {}
+
+ /**
+ * Sets the default task name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the task name to be dispatched
+ *
+ * @param string $taskName
+ */
+ public function setTaskName($taskName) {}
+
+ /**
+ * Gets last dispatched task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getLastTask() {}
+
+ /**
+ * Returns the active task in the dispatcher
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getActiveTask() {}
+
+ /**
+ * Set the options to be dispatched
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get dispatched options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/cli/Router.php b/ide/2.0.3/Phalcon/cli/Router.php
new file mode 100644
index 000000000..57c6a3f88
--- /dev/null
+++ b/ide/2.0.3/Phalcon/cli/Router.php
@@ -0,0 +1,211 @@
+Phalcon\Cli\Router is the standard framework router. Routing is the
+ * process of taking a command-line arguments and
+ * decomposing it into parameters to determine which module, task, and
+ * action of that task should receive the request
+ *
+ * $router = new \Phalcon\Cli\Router();
+ * $router->handle(array(
+ * 'module' => 'main',
+ * 'task' => 'videos',
+ * 'action' => 'process'
+ * ));
+ * echo $router->getTaskName();
+ *
+ */
+class Router implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_module;
+
+
+ protected $_task;
+
+
+ protected $_action;
+
+
+ protected $_params;
+
+
+ protected $_defaultModule = null;
+
+
+ protected $_defaultTask = null;
+
+
+ protected $_defaultAction = null;
+
+
+ protected $_defaultParams;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ /**
+ * Phalcon\Cli\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return Router
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Handles routing information received from command-line arguments
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Adds a route to the router
+ *
+ * $router->add('/about', 'About::main');
+ *
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function add($pattern, $paths = null) {}
+
+ /**
+ * Returns proccesed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns proccesed task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Returns proccesed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns proccesed extra params
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param int $id
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Cli\Router\Route
+ */
+ public function getRouteByName($name) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/cli/Task.php b/ide/2.0.3/Phalcon/cli/Task.php
new file mode 100644
index 000000000..5a8d068e5
--- /dev/null
+++ b/ide/2.0.3/Phalcon/cli/Task.php
@@ -0,0 +1,31 @@
+
+ * class HelloTask extends \Phalcon\Cli\Task
+ * {
+ * //This action will be executed by default
+ * public function mainAction()
+ * {
+ * }
+ * public function findAction()
+ * {
+ * }
+ * }
+ *
+ */
+class Task extends \Phalcon\Di\Injectable
+{
+
+ /**
+ * Phalcon\Cli\Task constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/cli/console/Exception.php b/ide/2.0.3/Phalcon/cli/console/Exception.php
new file mode 100644
index 000000000..91718714c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/cli/console/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callback $callback
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return mixed
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param callable $converter
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+ /**
+ * Set the routing delimiter
+ *
+ * @param string $delimiter
+ */
+ public static function delimiter($delimiter = null) {}
+
+ /**
+ * Get routing delimiter
+ *
+ * @return string
+ */
+ public static function getDelimiter() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/config/Exception.php b/ide/2.0.3/Phalcon/config/Exception.php
new file mode 100644
index 000000000..a6f27ac66
--- /dev/null
+++ b/ide/2.0.3/Phalcon/config/Exception.php
@@ -0,0 +1,12 @@
+
+ * [database]
+ * adapter = Mysql
+ * host = localhost
+ * username = scott
+ * password = cheetah
+ * dbname = test_db
+ * [phalcon]
+ * controllersDir = "../app/controllers/"
+ * modelsDir = "../app/models/"
+ * viewsDir = "../app/views/"
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Ini("path/config.ini");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Ini extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Ini constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+ /**
+ * Build multidimensional array from string
+ *
+ * $this->_parseIniString('path.hello.world', 'value for last key');
+ * // result
+ * [
+ * 'path' => [
+ * 'hello' => [
+ * 'world' => 'value for last key',
+ * ],
+ * ],
+ * ];
+ *
+ *
+ * @param string $path
+ * @param mixed $value
+ * @return array
+ */
+ protected function _parseIniString($path, $value) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/config/adapter/Json.php b/ide/2.0.3/Phalcon/config/adapter/Json.php
new file mode 100644
index 000000000..5ee81e9f3
--- /dev/null
+++ b/ide/2.0.3/Phalcon/config/adapter/Json.php
@@ -0,0 +1,29 @@
+
+ * {"phalcon":{"baseuri":"\/phalcon\/"},"models":{"metadata":"memory"}}
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Json("path/config.json");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Json extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Json constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/config/adapter/Php.php b/ide/2.0.3/Phalcon/config/adapter/Php.php
new file mode 100644
index 000000000..59f9634aa
--- /dev/null
+++ b/ide/2.0.3/Phalcon/config/adapter/Php.php
@@ -0,0 +1,42 @@
+
+ * array(
+ * 'adapter' => 'Mysql',
+ * 'host' => 'localhost',
+ * 'username' => 'scott',
+ * 'password' => 'cheetah',
+ * 'dbname' => 'test_db'
+ * ),
+ * phalcon' => array(
+ * 'controllersDir' => '../app/controllers/',
+ * 'modelsDir' => '../app/models/',
+ * 'viewsDir' => '../app/views/'
+ * ));
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Php("path/config.php");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Php extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Php constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/config/adapter/Yaml.php b/ide/2.0.3/Phalcon/config/adapter/Yaml.php
new file mode 100644
index 000000000..d9f5a9fe5
--- /dev/null
+++ b/ide/2.0.3/Phalcon/config/adapter/Yaml.php
@@ -0,0 +1,34 @@
+
+ * phalcon
+ * baseuri: /phalcon/
+ * models:
+ * metadata: memory
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Yaml("path/config.yaml");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Yaml extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Yaml constructor
+ *
+ * @throws \Phalcon\Config\Exception
+ * @param string $filePath
+ * @param array $callbacks
+ */
+ public function __construct($filePath, $callbacks = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/crypt/Exception.php b/ide/2.0.3/Phalcon/crypt/Exception.php
new file mode 100644
index 000000000..5af7d614f
--- /dev/null
+++ b/ide/2.0.3/Phalcon/crypt/Exception.php
@@ -0,0 +1,12 @@
+
+ * //Getting first robot
+ * $robot = $connection->fecthOne("SELECTFROM robots");
+ * print_r($robot);
+ * //Getting first robot with associative indexes only
+ * $robot = $connection->fecthOne("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $fetchMode
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return array
+ */
+ public function fetchOne($sqlQuery, $fetchMode = Db::FETCH_BOTH, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Dumps the complete result of a query into an array
+ *
+ * //Getting all robots with associative indexes only
+ * $robots = $connection->fetchAll("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * foreach ($robots as $robot) {
+ * print_r($robot);
+ * }
+ * //Getting all robots that contains word "robot" withing the name
+ * $robots = $connection->fetchAll("SELECTFROM robots WHERE name LIKE :name",
+ * Phalcon\Db::FETCH_ASSOC,
+ * array('name' => '%robot%')
+ * );
+ * foreach($robots as $robot){
+ * print_r($robot);
+ * }
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $fetchMode
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return array
+ */
+ public function fetchAll($sqlQuery, $fetchMode = 2, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Returns the n'th field of first row in a SQL query result
+ *
+ * //Getting count of robots
+ * $robotsCount = $connection->fetchColumn("SELECT count(*) FROM robots");
+ * print_r($robotsCount);
+ * //Getting name of last edited robot
+ * $robot = $connection->fetchColumn("SELECT id, name FROM robots order by modified desc");
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param array $placeholders
+ * @param int|string $column
+ * @return string|
+ */
+ public function fetchColumn($sqlQuery, $placeholders = null, $column = 0) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param string|array $table
+ * @param array $values
+ * @param mixed $fields
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @return
+ */
+ public function insert($table, $values, $fields = null, $dataTypes = null) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ * Another, more convenient syntax
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array(
+ * "name" => "Astro Boy",
+ * "year" => 1952
+ * )
+ * );
+ * //Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $dataTypes
+ * @param $string table
+ * @param $array dataTypes
+ * @return
+ */
+ public function insertAsDict($table, $data, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ * //Updating existing robot with array condition and $dataTypes
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * array(
+ * 'conditions' => "id = ?",
+ * 'bind' => array($some_unsafe_id),
+ * 'bindTypes' => array(PDO::PARAM_INT) //use only if you use $dataTypes param
+ * ),
+ * array(PDO::PARAM_STR)
+ * );
+ *
+ * Warning! If $whereCondition is string it not escaped.
+ *
+ * @param string|array $table
+ * @param mixed $fields
+ * @param mixed $values
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @param $string|array whereCondition
+ * @return
+ */
+ public function update($table, $fields, $values, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ * Another, more convenient syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array(
+ * "name" => "New Astro Boy"
+ * ),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $string whereCondition
+ * @param $array dataTypes
+ * @return
+ */
+ public function updateAsDict($table, $data, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Deletes data from a table using custom RBDM SQL syntax
+ *
+ * //Deleting existing robot
+ * $success = $connection->delete(
+ * "robots",
+ * "id = 101"
+ * );
+ * //Next SQL sentence is generated
+ * DELETE FROM `robots` WHERE `id` = 101
+ *
+ *
+ * @param string|array $table
+ * @param string $whereCondition
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return boolean
+ */
+ public function delete($table, $whereCondition = null, $placeholders = null, $dataTypes = null) {}
+
+ /**
+ * Gets a list of columns
+ *
+ * @param array columnList
+ * @return string
+ * @param mixed $columnList
+ * @return string
+ */
+ public function getColumnList($columnList) {}
+
+ /**
+ * Appends a LIMIT clause to $sqlQuery argument
+ *
+ * echo $connection->limit("SELECTFROM robots", 5);
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.table
+ *
+ * var_dump($connection->tableExists("blog", "posts"));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * var_dump($connection->viewExists("active_users", "posts"));
+ *
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Drops a table from a schema/database
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropTable($tableName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Creates a view
+ *
+ * @param string tableName
+ * @param array definition
+ * @param string schemaName
+ * @return boolean
+ * @param string $viewName
+ * @param array $definition
+ * @param mixed $schemaName
+ * @return bool
+ */
+ public function createView($viewName, $definition, $schemaName = null) {}
+
+ /**
+ * Drops a view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropView($viewName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Adds a column to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @return bool
+ */
+ public function addColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Drops a column from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $columnName
+ * @return bool
+ */
+ public function dropColumn($tableName, $schemaName, $columnName) {}
+
+ /**
+ * Adds an index to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addIndex($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drop an index from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $indexName
+ * @return bool
+ */
+ public function dropIndex($tableName, $schemaName, $indexName) {}
+
+ /**
+ * Adds a primary key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addPrimaryKey($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drops a table's primary key
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function dropPrimaryKey($tableName, $schemaName) {}
+
+ /**
+ * Adds a foreign key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $reference
+ * @return bool
+ */
+ public function addForeignKey($tableName, $schemaName, ReferenceInterface $reference) {}
+
+ /**
+ * Drops a foreign key from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $referenceName
+ * @return bool
+ */
+ public function dropForeignKey($tableName, $schemaName, $referenceName) {}
+
+ /**
+ * Returns the SQL column definition from a column
+ *
+ * @param mixed $column
+ * @return string
+ */
+ public function getColumnDefinition(\Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * List all tables on a database
+ *
+ * print_r($connection->listTables("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * List all views on a database
+ *
+ * print_r($connection->listViews("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * print_r($connection->describeIndexes('robots_parts'));
+ *
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\Index[]
+ * @param string $table
+ * @param mixed $schema
+ * @return Index
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * print_r($connection->describeReferences('robots_parts'));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return Reference
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Gets creation options from a table
+ *
+ * print_r($connection->tableOptions('robots'));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return array
+ */
+ public function tableOptions($tableName, $schemaName = null) {}
+
+ /**
+ * Creates a new savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Releases given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Rollbacks given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Set if nested transactions should use savepoints
+ *
+ * @param bool $nestedTransactionsWithSavepoints
+ * @return AdapterInterface
+ */
+ public function setNestedTransactionsWithSavepoints($nestedTransactionsWithSavepoints) {}
+
+ /**
+ * Returns if nested transactions should use savepoints
+ *
+ * @return bool
+ */
+ public function isNestedTransactionsWithSavepoints() {}
+
+ /**
+ * Returns the savepoint name to use for nested transactions
+ *
+ * @return string
+ */
+ public function getNestedTransactionSavepointName() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return descriptor used to connect to the active database
+ *
+ * @return array
+ */
+ public function getDescriptor() {}
+
+ /**
+ * Gets the active connection unique identifier
+ *
+ * @return string
+ */
+ public function getConnectionId() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return string
+ */
+ public function getSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object without replace bound paramters
+ *
+ * @return string
+ */
+ public function getRealSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return array
+ */
+ public function getSQLBindTypes() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/AdapterInterface.php b/ide/2.0.3/Phalcon/db/AdapterInterface.php
new file mode 100644
index 000000000..7726f24de
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/AdapterInterface.php
@@ -0,0 +1,559 @@
+
+ * use Phalcon\Db\Column as Column;
+ * //column definition
+ * $column = new Column("id", array(
+ * "type" => Column::TYPE_INTEGER,
+ * "size" => 10,
+ * "unsigned" => true,
+ * "notNull" => true,
+ * "autoIncrement" => true,
+ * "first" => true
+ * ));
+ * //add column to existing table
+ * $connection->addColumn("robots", null, $column);
+ *
+ */
+class Column implements \Phalcon\Db\ColumnInterface
+{
+ /**
+ * Integer abstract type
+ */
+ const TYPE_INTEGER = 0;
+
+ /**
+ * Date abstract type
+ */
+ const TYPE_DATE = 1;
+
+ /**
+ * Varchar abstract type
+ */
+ const TYPE_VARCHAR = 2;
+
+ /**
+ * Decimal abstract type
+ */
+ const TYPE_DECIMAL = 3;
+
+ /**
+ * Datetime abstract type
+ */
+ const TYPE_DATETIME = 4;
+
+ /**
+ * Char abstract type
+ */
+ const TYPE_CHAR = 5;
+
+ /**
+ * Text abstract data type
+ */
+ const TYPE_TEXT = 6;
+
+ /**
+ * Float abstract data type
+ */
+ const TYPE_FLOAT = 7;
+
+ /**
+ * Boolean abstract data type
+ */
+ const TYPE_BOOLEAN = 8;
+
+ /**
+ * Double abstract data type
+ */
+ const TYPE_DOUBLE = 9;
+
+ /**
+ * Bind Type Null
+ */
+ const BIND_PARAM_NULL = 0;
+
+ /**
+ * Bind Type Integer
+ */
+ const BIND_PARAM_INT = 1;
+
+ /**
+ * Bind Type String
+ */
+ const BIND_PARAM_STR = 2;
+
+ /**
+ * Bind Type Bool
+ */
+ const BIND_PARAM_BOOL = 5;
+
+ /**
+ * Bind Type Decimal
+ */
+ const BIND_PARAM_DECIMAL = 32;
+
+ /**
+ * Skip binding by type
+ */
+ const BIND_SKIP = 1024;
+
+ /**
+ * Column's name
+ *
+ * @var string
+ */
+ protected $_name;
+
+ /**
+ * Schema which table related is
+ *
+ * @var string
+ */
+ protected $_schemaName;
+
+ /**
+ * Column data type
+ *
+ * @var int|string
+ */
+ protected $_type;
+
+ /**
+ * Column data type reference
+ *
+ * @var int
+ */
+ protected $_typeReference;
+
+ /**
+ * Column data type values
+ *
+ * @var array|string
+ */
+ protected $_typeValues;
+
+ /**
+ * The column have some numeric type?
+ */
+ protected $_isNumeric = false;
+
+ /**
+ * Integer column size
+ *
+ * @var int
+ */
+ protected $_size = 0;
+
+ /**
+ * Integer column number scale
+ *
+ * @var int
+ */
+ protected $_scale = 0;
+
+ /**
+ * Default column value
+ */
+ protected $_default = null;
+
+ /**
+ * Integer column unsigned?
+ *
+ * @var boolean
+ */
+ protected $_unsigned = false;
+
+ /**
+ * Column not nullable?
+ *
+ * @var boolean
+ */
+ protected $_notNull = false;
+
+ /**
+ * Column is part of the primary key?
+ */
+ protected $_primary = false;
+
+ /**
+ * Column is autoIncrement?
+ *
+ * @var boolean
+ */
+ protected $_autoIncrement = false;
+
+ /**
+ * Position is first
+ *
+ * @var boolean
+ */
+ protected $_first = false;
+
+ /**
+ * Column Position
+ *
+ * @var string
+ */
+ protected $_after;
+
+ /**
+ * Bind Type
+ */
+ protected $_bindType = 2;
+
+
+ /**
+ * Column's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Schema which table related is
+ *
+ * @return string
+ */
+ public function getSchemaName() {}
+
+ /**
+ * Column data type
+ *
+ * @return int|string
+ */
+ public function getType() {}
+
+ /**
+ * Column data type reference
+ *
+ * @return int
+ */
+ public function getTypeReference() {}
+
+ /**
+ * Column data type values
+ *
+ * @return array|string
+ */
+ public function getTypeValues() {}
+
+ /**
+ * Integer column size
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Integer column number scale
+ *
+ * @return int
+ */
+ public function getScale() {}
+
+ /**
+ * Default column value
+ */
+ public function getDefault() {}
+
+ /**
+ * Phalcon\Db\Column constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Returns true if number column is unsigned
+ *
+ * @return bool
+ */
+ public function isUnsigned() {}
+
+ /**
+ * Not null
+ *
+ * @return bool
+ */
+ public function isNotNull() {}
+
+ /**
+ * Column is part of the primary key?
+ *
+ * @return bool
+ */
+ public function isPrimary() {}
+
+ /**
+ * Auto-Increment
+ *
+ * @return bool
+ */
+ public function isAutoIncrement() {}
+
+ /**
+ * Check whether column have an numeric type
+ *
+ * @return bool
+ */
+ public function isNumeric() {}
+
+ /**
+ * Check whether column have first position in table
+ *
+ * @return bool
+ */
+ public function isFirst() {}
+
+ /**
+ * Check whether field absolute to position in table
+ *
+ * @return string
+ */
+ public function getAfterPosition() {}
+
+ /**
+ * Returns the type of bind handling
+ *
+ * @return int
+ */
+ public function getBindType() {}
+
+ /**
+ * Restores the internal state of a Phalcon\Db\Column object
+ *
+ * @param array $data
+ * @return Column
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/ColumnInterface.php b/ide/2.0.3/Phalcon/db/ColumnInterface.php
new file mode 100644
index 000000000..658903aaf
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/ColumnInterface.php
@@ -0,0 +1,140 @@
+
+ * $sql = $dialect->limit('SELECTFROM robots', 10);
+ * echo $sql; // SELECTFROM robots LIMIT 10
+ * $sql = $dialect->limit('SELECTFROM robots', [10, 50]);
+ * echo $sql; // SELECTFROM robots LIMIT 10 OFFSET 50
+ *
+ *
+ * @param string $sqlQuery
+ * @param mixed $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * $sql = $dialect->forUpdate('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots FOR UPDATE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * $sql = $dialect->sharedLock('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots LOCK IN SHARE MODE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Gets a list of columns with escaped identifiers
+ *
+ * echo $dialect->getColumnList(array('column1', 'column'));
+ *
+ *
+ * @param array $columnList
+ * @return string
+ */
+ public final function getColumnList($columnList) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param mixed $column
+ * @return string
+ */
+ public final function getSqlColumn($column) {}
+
+ /**
+ * Transforms an intermediate representation for a expression into a database system valid expression
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ public function getSqlExpression($expression, $escapeChar = null) {}
+
+ /**
+ * Transform an intermediate representation of a schema/table into a database system valid expression
+ *
+ * @param mixed $table
+ * @param string $escapeChar
+ * @return string
+ */
+ public final function getSqlTable($table, $escapeChar = null) {}
+
+ /**
+ * Builds a SELECT statement
+ *
+ * @param array $definition
+ * @return string
+ */
+ public function select($definition) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+ /**
+ * Generate SQL to create a new savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Generate SQL to release a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Generate SQL to rollback a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionScalar($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve object expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionObject($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve qualified expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionQualified($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve binary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionBinaryOperations($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve unary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionUnaryOperations($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve function calls
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionFunctionCall($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve Lists
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionList($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionAll($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CAST of values
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionCastValue($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CONVERT of values encodings
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionConvertValue($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CASE expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionCase($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a FROM clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionFrom($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a JOINs clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionJoins($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a WHERE clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionWhere($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a GROUP BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionGroupBy($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a HAVING clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionHaving($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a ORDER BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionOrderBy($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a LIMIT clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionLimit($expression, $escapeChar = null) {}
+
+ /**
+ * Prepares column for this RDBMS
+ *
+ * @param string $qualified
+ * @param string $alias
+ * @return string
+ */
+ protected function prepareColumnAlias($qualified, $alias = null) {}
+
+ /**
+ * Prepares table for this RDBMS
+ *
+ * @param string $table
+ * @param string $schema
+ * @param string $alias
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareTable($table, $schema = null, $alias = null, $escapeChar = null) {}
+
+ /**
+ * Prepares qualified for this RDBMS
+ *
+ * @param string $column
+ * @param string $domain
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareQualified($column, $domain = null, $escapeChar = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/DialectInterface.php b/ide/2.0.3/Phalcon/db/DialectInterface.php
new file mode 100644
index 000000000..a1deb6019
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/DialectInterface.php
@@ -0,0 +1,290 @@
+
+ * $profiler = new \Phalcon\Db\Profiler();
+ * //Set the connection profiler
+ * $connection->setProfiler($profiler);
+ * $sql = "SELECT buyer_name, quantity, product_name
+ * FROM buyers LEFT JOIN products ON
+ * buyers.pid=products.id";
+ * //Execute a SQL statement
+ * $connection->query($sql);
+ * //Get the last profile in the profiler
+ * $profile = $profiler->getLastProfile();
+ * echo "SQL Statement: ", $profile->getSQLStatement(), "\n";
+ * echo "Start Time: ", $profile->getInitialTime(), "\n";
+ * echo "Final Time: ", $profile->getFinalTime(), "\n";
+ * echo "Total Elapsed Time: ", $profile->getTotalElapsedSeconds(), "\n";
+ *
+ */
+class Profiler
+{
+ /**
+ * All the Phalcon\Db\Profiler\Item in the active profile
+ *
+ * @var array
+ */
+ protected $_allProfiles;
+
+ /**
+ * Active Phalcon\Db\Profiler\Item
+ *
+ * @var Phalcon\Db\Profiler\Item
+ */
+ protected $_activeProfile;
+
+ /**
+ * Total time spent by all profiles to complete
+ *
+ * @var float
+ */
+ protected $_totalSeconds = 0;
+
+
+ /**
+ * Starts the profile of a SQL sentence
+ *
+ * @param string $sqlStatement
+ * @param mixed $sqlVariables
+ * @param mixed $sqlBindTypes
+ * @return \Phalcon\Db\Profiler
+ */
+ public function startProfile($sqlStatement, $sqlVariables = null, $sqlBindTypes = null) {}
+
+ /**
+ * Stops the active profile
+ *
+ * @return Profiler
+ */
+ public function stopProfile() {}
+
+ /**
+ * Returns the total number of SQL statements processed
+ *
+ * @return int
+ */
+ public function getNumberTotalStatements() {}
+
+ /**
+ * Returns the total time in seconds spent by the profiles
+ *
+ * @return double
+ */
+ public function getTotalElapsedSeconds() {}
+
+ /**
+ * Returns all the processed profiles
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getProfiles() {}
+
+ /**
+ * Resets the profiler, cleaning up all the profiles
+ *
+ * @return Profiler
+ */
+ public function reset() {}
+
+ /**
+ * Returns the last profile executed in the profiler
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getLastProfile() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/RawValue.php b/ide/2.0.3/Phalcon/db/RawValue.php
new file mode 100644
index 000000000..6274e2070
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/RawValue.php
@@ -0,0 +1,45 @@
+
+ * $subscriber = new Subscribers();
+ * $subscriber->email = 'andres@phalconphp.com';
+ * $subscriber->createdAt = new \Phalcon\Db\RawValue('now()');
+ * $subscriber->save();
+ *
+ */
+class RawValue
+{
+ /**
+ * Raw value without quoting or formating
+ *
+ * @var string
+ */
+ protected $_value;
+
+
+ /**
+ * Raw value without quoting or formating
+ *
+ * @return string
+ */
+ public function getValue() {}
+
+ /**
+ * Raw value without quoting or formating
+ */
+ public function __toString() {}
+
+ /**
+ * Phalcon\Db\RawValue constructor
+ *
+ * @param string $value
+ */
+ public function __construct($value) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/Reference.php b/ide/2.0.3/Phalcon/db/Reference.php
new file mode 100644
index 000000000..ad0ca1f80
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/Reference.php
@@ -0,0 +1,132 @@
+
+ * $reference = new \Phalcon\Db\Reference("field_fk", array(
+ * 'referencedSchema' => "invoicing",
+ * 'referencedTable' => "products",
+ * 'columns' => array("product_type", "product_code"),
+ * 'referencedColumns' => array("type", "code")
+ * ));
+ *
+ */
+class Reference implements \Phalcon\Db\ReferenceInterface
+{
+ /**
+ * Constraint name
+ *
+ * @var string
+ */
+ protected $_name;
+
+
+ protected $_schemaName;
+
+
+ protected $_referencedSchema;
+
+ /**
+ * Referenced Table
+ *
+ * @var string
+ */
+ protected $_referencedTable;
+
+ /**
+ * Local reference columns
+ *
+ * @var array
+ */
+ protected $_columns;
+
+ /**
+ * Referenced Columns
+ *
+ * @var array
+ */
+ protected $_referencedColumns;
+
+ /**
+ * ON DELETE
+ *
+ * @var array
+ */
+ protected $_onDelete;
+
+ /**
+ * ON UPDATE
+ *
+ * @var array
+ */
+ protected $_onUpdate;
+
+
+ /**
+ * Constraint name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+
+ public function getSchemaName() {}
+
+
+ public function getReferencedSchema() {}
+
+ /**
+ * Referenced Table
+ *
+ * @return string
+ */
+ public function getReferencedTable() {}
+
+ /**
+ * Local reference columns
+ *
+ * @return array
+ */
+ public function getColumns() {}
+
+ /**
+ * Referenced Columns
+ *
+ * @return array
+ */
+ public function getReferencedColumns() {}
+
+ /**
+ * ON DELETE
+ *
+ * @return array
+ */
+ public function getOnDelete() {}
+
+ /**
+ * ON UPDATE
+ *
+ * @return array
+ */
+ public function getOnUpdate() {}
+
+ /**
+ * Phalcon\Db\Reference constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Restore a Phalcon\Db\Reference object from export
+ *
+ * @param array $data
+ * @return Reference
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/ReferenceInterface.php b/ide/2.0.3/Phalcon/db/ReferenceInterface.php
new file mode 100644
index 000000000..89e52781f
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/ReferenceInterface.php
@@ -0,0 +1,84 @@
+
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306'
+ * ));
+ *
+ */
+abstract class Pdo extends \Phalcon\Db\Adapter
+{
+ /**
+ * PDO Handler
+ */
+ protected $_pdo;
+
+ /**
+ * Last affected rows
+ */
+ protected $_affectedRows;
+
+
+ /**
+ * Constructor for Phalcon\Db\Adapter\Pdo
+ *
+ * @param array $descriptor
+ */
+ public function __construct($descriptor) {}
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection
+ *
+ * //Make a connection
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * ));
+ * //Reconnect
+ * $connection->connect();
+ *
+ *
+ * @param mixed $descriptor
+ * @param $array descriptor
+ * @return
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns a PDO prepared statement to be executed with 'executePrepared'
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param string $sqlStatement
+ * @return \PDOStatement
+ */
+ public function prepare($sqlStatement) {}
+
+ /**
+ * Executes a prepared statement binding. This function uses integer indexes starting from zero
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param \PDOStatement $statement
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return \PDOStatement
+ */
+ public function executePrepared(\PDOStatement $statement, $placeholders, $dataTypes) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server is returning rows
+ *
+ * //Querying data
+ * $resultset = $connection->query("SELECTFROM robots WHERE type='mechanical'");
+ * $resultset = $connection->query("SELECTFROM robots WHERE type=?", array("mechanical"));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool|\Phalcon\Db\ResultInterface
+ */
+ public function query($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server doesn't return any rows
+ *
+ * //Inserting data
+ * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
+ * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool
+ */
+ public function execute($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Returns the number of affected rows by the lastest INSERT/UPDATE/DELETE executed in the database system
+ *
+ * $connection->execute("DELETE FROM robots");
+ * echo $connection->affectedRows(), ' were deleted';
+ *
+ *
+ * @return int
+ */
+ public function affectedRows() {}
+
+ /**
+ * Closes the active connection returning success. Phalcon automatically closes and destroys
+ * active connections when the request ends
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * $escapedTable = $connection->escapeIdentifier('robots');
+ * $escapedTable = $connection->escapeIdentifier(array('store', 'robots'));
+ *
+ *
+ * @param string $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Escapes a value to avoid SQL injections according to the active charset in the connection
+ *
+ * $escapedStr = $connection->escapeString('some dangerous value');
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public function escapeString($str) {}
+
+ /**
+ * Converts bound parameters such as :name: or ?1 into PDO bind params ?
+ *
+ * print_r($connection->convertBoundParams('SELECTFROM robots WHERE name = :name:', array('Bender')));
+ *
+ *
+ * @param string $sql
+ * @param array $params
+ * @return array
+ */
+ public function convertBoundParams($sql, $params = array()) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int|boolean
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Starts a transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function begin($nesting = true) {}
+
+ /**
+ * Rollbacks the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function rollback($nesting = true) {}
+
+ /**
+ * Commits the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function commit($nesting = true) {}
+
+ /**
+ * Returns the current transaction nesting level
+ *
+ * @return int
+ */
+ public function getTransactionLevel() {}
+
+ /**
+ * Checks whether the connection is under a transaction
+ *
+ * $connection->begin();
+ * var_dump($connection->isUnderTransaction()); //true
+ *
+ *
+ * @return bool
+ */
+ public function isUnderTransaction() {}
+
+ /**
+ * Return internal PDO handler
+ *
+ * @return \Pdo
+ */
+ public function getInternalHandler() {}
+
+ /**
+ * Return the error info, if any
+ *
+ * @return array
+ */
+ public function getErrorInfo() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/adapter/pdo/Mysql.php b/ide/2.0.3/Phalcon/db/adapter/pdo/Mysql.php
new file mode 100644
index 000000000..dec124c0e
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/adapter/pdo/Mysql.php
@@ -0,0 +1,48 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "port" => 3306,
+ * "username" => "sigma",
+ * "password" => "secret"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql($config);
+ *
+ */
+class Mysql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "mysql";
+
+
+ protected $_dialectType = "mysql";
+
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * @param string|array $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/adapter/pdo/Oracle.php b/ide/2.0.3/Phalcon/db/adapter/pdo/Oracle.php
new file mode 100644
index 000000000..9e45aea25
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/adapter/pdo/Oracle.php
@@ -0,0 +1,84 @@
+
+ * $config = array(
+ * "dbname" => "//localhost/dbname",
+ * "username" => "oracle",
+ * "password" => "oracle"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Oracle($config);
+ *
+ */
+class Oracle extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "oci";
+
+
+ protected $_dialectType = "oracle";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param array $descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ * print_r($connection->describeColumns("posts")); ?>
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return the default identity value to insert in an identity column
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/adapter/pdo/Postgresql.php b/ide/2.0.3/Phalcon/db/adapter/pdo/Postgresql.php
new file mode 100644
index 000000000..301ae233c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/adapter/pdo/Postgresql.php
@@ -0,0 +1,99 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "username" => "postgres",
+ * "password" => ""
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Postgresql($config);
+ *
+ */
+class Postgresql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "pgsql";
+
+
+ protected $_dialectType = "postgresql";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/adapter/pdo/Sqlite.php b/ide/2.0.3/Phalcon/db/adapter/pdo/Sqlite.php
new file mode 100644
index 000000000..81a81311e
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/adapter/pdo/Sqlite.php
@@ -0,0 +1,77 @@
+
+ * $config = array(
+ * "dbname" => "/tmp/test.sqlite"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Sqlite($config);
+ *
+ */
+class Sqlite extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "sqlite";
+
+
+ protected $_dialectType = "sqlite";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\IndexInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\IndexInterface
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\ReferenceInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\ReferenceInterface
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/dialect/MySQL.php b/ide/2.0.3/Phalcon/db/dialect/MySQL.php
new file mode 100644
index 000000000..6e8af8d16
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/dialect/MySQL.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Generates SQL to add the table creation options
+ *
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/dialect/Oracle.php b/ide/2.0.3/Phalcon/db/dialect/Oracle.php
new file mode 100644
index 000000000..972fdf46e
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/dialect/Oracle.php
@@ -0,0 +1,257 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/dialect/Postgresql.php b/ide/2.0.3/Phalcon/db/dialect/Postgresql.php
new file mode 100644
index 000000000..0a3b9f37e
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/dialect/Postgresql.php
@@ -0,0 +1,239 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/dialect/Sqlite.php b/ide/2.0.3/Phalcon/db/dialect/Sqlite.php
new file mode 100644
index 000000000..c606ad0c5
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/dialect/Sqlite.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query indexes detail on a table
+ *
+ * @param string $index
+ * @return string
+ */
+ public function describeIndex($index) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/db/profiler/Item.php b/ide/2.0.3/Phalcon/db/profiler/Item.php
new file mode 100644
index 000000000..79ad83855
--- /dev/null
+++ b/ide/2.0.3/Phalcon/db/profiler/Item.php
@@ -0,0 +1,124 @@
+
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ */
+class Pdo implements \Phalcon\Db\ResultInterface
+{
+
+ protected $_connection;
+
+
+ protected $_result;
+
+ /**
+ * Active fetch mode
+ */
+ protected $_fetchMode = Db::FETCH_OBJ;
+
+ /**
+ * Internal resultset
+ *
+ * @var \PDOStatement
+ */
+ protected $_pdoStatement;
+
+
+ protected $_sqlStatement;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_rowCount = false;
+
+
+ /**
+ * Phalcon\Db\Result\Pdo constructor
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \PDOStatement $result
+ * @param string $sqlStatement
+ * @param array $bindParams
+ * @param array $bindTypes
+ */
+ public function __construct(Db\AdapterInterface $connection, \PDOStatement $result, $sqlStatement = null, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Allows to execute the statement again. Some database systems don't support scrollable cursors,
+ * So, as cursors are forward only, we need to execute the cursor again to fetch rows from the begining
+ *
+ * @return bool
+ */
+ public function execute() {}
+
+ /**
+ * Fetches an array/object of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ * while ($robot = $result->fetch()) {
+ * echo robot->name;
+ * }
+ *
+ *
+ * @return mixed
+ */
+ public function fetch() {}
+
+ /**
+ * Returns an array of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ *
+ * @return mixed
+ */
+ public function fetchArray() {}
+
+ /**
+ * Returns an array of arrays containing all the records in the result
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $robots = $result->fetchAll();
+ *
+ *
+ * @return array
+ */
+ public function fetchAll() {}
+
+ /**
+ * Gets number of rows returned by a resultset
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * echo 'There are ', $result->numRows(), ' rows in the resultset';
+ *
+ *
+ * @return int
+ */
+ public function numRows() {}
+
+ /**
+ * Moves internal resultset cursor to another position letting us to fetch a certain row
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->dataSeek(2); // Move to third row on result
+ * $row = $result->fetch(); // Fetch third row
+ *
+ *
+ * @param long $number
+ */
+ public function dataSeek($number) {}
+
+ /**
+ * Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch()
+ *
+ * //Return array with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * //Return associative array without integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_ASSOC);
+ * //Return associative array together with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_BOTH);
+ * //Return an object
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ *
+ *
+ * @param int $fetchMode
+ */
+ public function setFetchMode($fetchMode) {}
+
+ /**
+ * Gets the internal PDO result object
+ *
+ * @return \PDOStatement
+ */
+ public function getInternalResult() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/debug/Dump.php b/ide/2.0.3/Phalcon/debug/Dump.php
new file mode 100644
index 000000000..6562d828c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/debug/Dump.php
@@ -0,0 +1,119 @@
+
+ * $foo = 123;
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ */
+class Dump
+{
+
+ protected $_detailed = false;
+
+
+ protected $_methods = null;
+
+
+ protected $_styles;
+
+
+
+ public function getDetailed() {}
+
+ /**
+ * @param mixed $detailed
+ */
+ public function setDetailed($detailed) {}
+
+ /**
+ * Phalcon\Debug\Dump constructor
+ *
+ * @param array $styles
+ * @param boolean $detailed debug object's private and protected properties
+ */
+ public function __construct($styles = null, $detailed = false) {}
+
+ /**
+ * Alias of variables() method
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function all() {}
+
+ /**
+ * Get style for type
+ *
+ * @param string $type
+ * @return string
+ */
+ protected function getStyle($type) {}
+
+ /**
+ * Set styles for vars type
+ *
+ * @param mixed $styles
+ * @return array
+ */
+ public function setStyles($styles = null) {}
+
+ /**
+ * Alias of variable() method
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function one($variable, $name = null) {}
+
+ /**
+ * Prepare an HTML string of information about a single variable.
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @param int $tab
+ * @return string
+ */
+ protected function output($variable, $name = null, $tab = 1) {}
+
+ /**
+ * Returns an HTML string of information about a single variable.
+ *
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function variable($variable, $name = null) {}
+
+ /**
+ * Returns an HTML string of debugging information about any number of
+ * variables, each wrapped in a "pre" tag.
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function variables() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/debug/Exception.php b/ide/2.0.3/Phalcon/debug/Exception.php
new file mode 100644
index 000000000..12c2c2b76
--- /dev/null
+++ b/ide/2.0.3/Phalcon/debug/Exception.php
@@ -0,0 +1,12 @@
+
+ * $service = new \Phalcon\Di\Service('request', 'Phalcon\Http\Request');
+ * $request = service->resolve();
+ *
+ */
+class Service implements \Phalcon\Di\ServiceInterface
+{
+
+ protected $_name;
+
+
+ protected $_definition;
+
+
+ protected $_shared = false;
+
+
+ protected $_resolved = false;
+
+
+ protected $_sharedInstance;
+
+
+ /**
+ * Phalcon\Di\Service
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param boolean $shared
+ */
+ public final function __construct($name, $definition, $shared = false) {}
+
+ /**
+ * Returns the service's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets if the service is shared or not
+ *
+ * @param bool $shared
+ */
+ public function setShared($shared) {}
+
+ /**
+ * Check whether the service is shared or not
+ *
+ * @return bool
+ */
+ public function isShared() {}
+
+ /**
+ * Sets/Resets the shared instance related to the service
+ *
+ * @param mixed $sharedInstance
+ */
+ public function setSharedInstance($sharedInstance) {}
+
+ /**
+ * Set the service definition
+ *
+ * @param mixed $definition
+ */
+ public function setDefinition($definition) {}
+
+ /**
+ * Returns the service definition
+ *
+ * @return mixed
+ */
+ public function getDefinition() {}
+
+ /**
+ * Resolves the service
+ *
+ * @param array $parameters
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @return mixed
+ */
+ public function resolve($parameters = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Changes a parameter in the definition without resolve the service
+ *
+ * @param int $position
+ * @param array $parameter
+ * @return Service
+ */
+ public function setParameter($position, $parameter) {}
+
+ /**
+ * Returns a parameter in a specific position
+ *
+ * @param int $position
+ * @return array
+ */
+ public function getParameter($position) {}
+
+ /**
+ * Returns true if the service was resolved
+ *
+ * @return bool
+ */
+ public function isResolved() {}
+
+ /**
+ * Restore the internal state of a service
+ *
+ * @param array $attributes
+ * @return Service
+ */
+ public static function __set_state($attributes) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/di/ServiceInterface.php b/ide/2.0.3/Phalcon/di/ServiceInterface.php
new file mode 100644
index 000000000..97df909cf
--- /dev/null
+++ b/ide/2.0.3/Phalcon/di/ServiceInterface.php
@@ -0,0 +1,73 @@
+
+ * $eventsManager->fire('db', $connection);
+ *
+ *
+ * @param string $eventType
+ * @param object $source
+ * @param mixed $data
+ * @param boolean $cancelable
+ * @return mixed
+ */
+ public function fire($eventType, $source, $data = null, $cancelable = true) {}
+
+ /**
+ * Check whether certain type of event has listeners
+ *
+ * @param string $type
+ * @return bool
+ */
+ public function hasListeners($type) {}
+
+ /**
+ * Returns all the attached listeners of a certain type
+ *
+ * @param string $type
+ * @return array
+ */
+ public function getListeners($type) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/events/ManagerInterface.php b/ide/2.0.3/Phalcon/events/ManagerInterface.php
new file mode 100644
index 000000000..394032467
--- /dev/null
+++ b/ide/2.0.3/Phalcon/events/ManagerInterface.php
@@ -0,0 +1,55 @@
+Encapsulates request information for easy and secure access from application controllers.
+ * The request object is a simple value object that is passed between the dispatcher and controller classes. + * It packages the HTTP request environment.
+ *
+ * $request = new \Phalcon\Http\Request();
+ * if ($request->isPost() == true) {
+ * if ($request->isAjax() == true) {
+ * echo 'Request was made using POST and AJAX';
+ * }
+ * }
+ *
+ */
+class Request implements \Phalcon\Http\RequestInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_rawBody;
+
+
+ protected $_filter;
+
+
+ protected $_putCache;
+
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Gets a variable from the $_REQUEST superglobal applying filters if needed.
+ * If no parameters are given the $_REQUEST superglobal is returned
+ *
+ * //Returns value from $_REQUEST["user_email"] without sanitizing
+ * $userEmail = $request->get("user_email");
+ * //Returns value from $_REQUEST["user_email"] with sanitizing
+ * $userEmail = $request->get("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function get($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from the $_POST superglobal applying filters if needed
+ * If no parameters are given the $_POST superglobal is returned
+ *
+ * //Returns value from $_POST["user_email"] without sanitizing
+ * $userEmail = $request->getPost("user_email");
+ * //Returns value from $_POST["user_email"] with sanitizing
+ * $userEmail = $request->getPost("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPost($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from put request
+ *
+ * //Returns value from $_PUT["user_email"] without sanitizing
+ * $userEmail = $request->getPut("user_email");
+ * //Returns value from $_PUT["user_email"] with sanitizing
+ * $userEmail = $request->getPut("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPut($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_GET superglobal applying filters if needed
+ * If no parameters are given the $_GET superglobal is returned
+ *
+ * //Returns value from $_GET["id"] without sanitizing
+ * $id = $request->getQuery("id");
+ * //Returns value from $_GET["id"] with sanitizing
+ * $id = $request->getQuery("id", "int");
+ * //Returns value from $_GET["id"] with a default value
+ * $id = $request->getQuery("id", null, 150);
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getQuery($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Helper to get data from superglobals, applying filters if needed.
+ * If no parameters are given the superglobal is returned.
+ *
+ * @param array $source
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ protected final function getHelper($source, $name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_SERVER superglobal
+ *
+ * @param string $name
+ */
+ public function getServer($name) {}
+
+ /**
+ * Checks whether $_REQUEST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Checks whether $_POST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPost($name) {}
+
+ /**
+ * Checks whether the PUT data has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPut($name) {}
+
+ /**
+ * Checks whether $_GET superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasQuery($name) {}
+
+ /**
+ * Checks whether $_SERVER superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public final function hasServer($name) {}
+
+ /**
+ * Gets HTTP header from request data
+ *
+ * @param string $header
+ * @return string
+ */
+ public final function getHeader($header) {}
+
+ /**
+ * Gets HTTP schema (http/https)
+ *
+ * @return string
+ */
+ public function getScheme() {}
+
+ /**
+ * Checks whether request has been made using ajax
+ *
+ * @return bool
+ */
+ public function isAjax() {}
+
+ /**
+ * Checks whether request has been made using SOAP
+ *
+ * @return bool
+ */
+ public function isSoapRequested() {}
+
+ /**
+ * Checks whether request has been made using any secure layer
+ *
+ * @return bool
+ */
+ public function isSecureRequest() {}
+
+ /**
+ * Gets HTTP raw request body
+ *
+ * @return string
+ */
+ public function getRawBody() {}
+
+ /**
+ * Gets decoded JSON HTTP raw request body
+ *
+ * @param bool $associative
+ * @return array|bool|\stdClass
+ */
+ public function getJsonRawBody($associative = false) {}
+
+ /**
+ * Gets active server address IP
+ *
+ * @return string
+ */
+ public function getServerAddress() {}
+
+ /**
+ * Gets active server name
+ *
+ * @return string
+ */
+ public function getServerName() {}
+
+ /**
+ * Gets information about schema, host and port used by the request
+ *
+ * @return string
+ */
+ public function getHttpHost() {}
+
+ /**
+ * Gets HTTP URI which request has been made
+ *
+ * @return string
+ */
+ public final function getURI() {}
+
+ /**
+ * Gets most possible client IPv4 Address. This method search in _SERVER['REMOTE_ADDR'] and optionally in _SERVER['HTTP_X_FORWARDED_FOR']
+ *
+ * @param bool $trustForwardedHeader
+ * @return string|bool
+ */
+ public function getClientAddress($trustForwardedHeader = false) {}
+
+ /**
+ * Gets HTTP method which request has been made
+ *
+ * @return string
+ */
+ public final function getMethod() {}
+
+ /**
+ * Gets HTTP user agent used to made the request
+ *
+ * @return string
+ */
+ public function getUserAgent() {}
+
+ /**
+ * Check if HTTP method match any of the passed methods
+ *
+ * @param mixed $methods
+ * @return bool
+ */
+ public function isMethod($methods) {}
+
+ /**
+ * Checks whether HTTP method is POST. if _SERVER["REQUEST_METHOD"]==="POST"
+ *
+ * @return bool
+ */
+ public function isPost() {}
+
+ /**
+ * Checks whether HTTP method is GET. if _SERVER["REQUEST_METHOD"]==="GET"
+ *
+ * @return bool
+ */
+ public function isGet() {}
+
+ /**
+ * Checks whether HTTP method is PUT. if _SERVER["REQUEST_METHOD"]==="PUT"
+ *
+ * @return bool
+ */
+ public function isPut() {}
+
+ /**
+ * Checks whether HTTP method is PATCH. if _SERVER["REQUEST_METHOD"]==="PATCH"
+ *
+ * @return bool
+ */
+ public function isPatch() {}
+
+ /**
+ * Checks whether HTTP method is HEAD. if _SERVER["REQUEST_METHOD"]==="HEAD"
+ *
+ * @return bool
+ */
+ public function isHead() {}
+
+ /**
+ * Checks whether HTTP method is DELETE. if _SERVER["REQUEST_METHOD"]==="DELETE"
+ *
+ * @return bool
+ */
+ public function isDelete() {}
+
+ /**
+ * Checks whether HTTP method is OPTIONS. if _SERVER["REQUEST_METHOD"]==="OPTIONS"
+ *
+ * @return bool
+ */
+ public function isOptions() {}
+
+ /**
+ * Checks whether request include attached files
+ *
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ public function hasFiles($onlySuccessful = false) {}
+
+ /**
+ * Recursively counts file in an array of files
+ *
+ * @param mixed $data
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ protected final function hasFileHelper($data, $onlySuccessful) {}
+
+ /**
+ * Gets attached files as Phalcon\Http\Request\File instances
+ *
+ * @param bool $onlySuccessful
+ * @return \Phalcon\Http\Request\File
+ */
+ public function getUploadedFiles($onlySuccessful = false) {}
+
+ /**
+ * Smooth out $_FILES to have plain array with all files uploaded
+ *
+ * @param array $names
+ * @param array $types
+ * @param array $tmp_names
+ * @param array $sizes
+ * @param array $errors
+ * @param string $prefix
+ * @return array
+ */
+ protected final function smoothFiles($names, $types, $tmp_names, $sizes, $errors, $prefix) {}
+
+ /**
+ * Returns the available headers in the request
+ *
+ * @return array
+ */
+ public function getHeaders() {}
+
+ /**
+ * Gets web page that refers active request. ie: http://www.google.com
+ *
+ * @return string
+ */
+ public function getHTTPReferer() {}
+
+ /**
+ * Process a request header and return an array of values with their qualities
+ *
+ * @param string $serverIndex
+ * @param string $name
+ * @return array
+ */
+ protected final function _getQualityHeader($serverIndex, $name) {}
+
+ /**
+ * Process a request header and return the one with best quality
+ *
+ * @param array $qualityParts
+ * @param string $name
+ * @return string
+ */
+ protected final function _getBestQuality($qualityParts, $name) {}
+
+ /**
+ * Gets content type which request has been made
+ *
+ * @return string|null
+ */
+ public function getContentType() {}
+
+ /**
+ * Gets an array with mime/types and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return array
+ */
+ public function getAcceptableContent() {}
+
+ /**
+ * Gets best mime/type accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return string
+ */
+ public function getBestAccept() {}
+
+ /**
+ * Gets a charsets array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return variable
+ */
+ public function getClientCharsets() {}
+
+ /**
+ * Gets best charset accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return string
+ */
+ public function getBestCharset() {}
+
+ /**
+ * Gets languages array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return array
+ */
+ public function getLanguages() {}
+
+ /**
+ * Gets best language accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return string
+ */
+ public function getBestLanguage() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_USER']
+ *
+ * @return array|null
+ */
+ public function getBasicAuth() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_DIGEST']
+ *
+ * @return array
+ */
+ public function getDigestAuth() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/http/RequestInterface.php b/ide/2.0.3/Phalcon/http/RequestInterface.php
new file mode 100644
index 000000000..f19db997b
--- /dev/null
+++ b/ide/2.0.3/Phalcon/http/RequestInterface.php
@@ -0,0 +1,305 @@
+
+ * $response = new \Phalcon\Http\Response();
+ * $response->setStatusCode(200, "OK");
+ * $response->setContent("Hello");
+ * $response->send();
+ *
+ */
+class Response implements \Phalcon\Http\ResponseInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_sent = false;
+
+
+ protected $_content;
+
+
+ protected $_headers;
+
+
+ protected $_cookies;
+
+
+ protected $_file;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_statusCodes;
+
+
+ /**
+ * Phalcon\Http\Response constructor
+ *
+ * @param string $content
+ * @param int $code
+ * @param string $status
+ */
+ public function __construct($content = null, $code = null, $status = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the HTTP response code
+ *
+ * $response->setStatusCode(404, "Not Found");
+ *
+ *
+ * @param int $code
+ * @param string $message
+ * @return Response
+ */
+ public function setStatusCode($code, $message = null) {}
+
+ /**
+ * Returns the status code
+ *
+ * print_r($response->getStatusCode());
+ *
+ *
+ * @return array
+ */
+ public function getStatusCode() {}
+
+ /**
+ * Sets a headers bag for the response externally
+ *
+ * @param mixed $headers
+ * @return Response
+ */
+ public function setHeaders(\Phalcon\Http\Response\HeadersInterface $headers) {}
+
+ /**
+ * Returns headers set by the user
+ *
+ * @return \Phalcon\Http\Response\HeadersInterface
+ */
+ public function getHeaders() {}
+
+ /**
+ * Sets a cookies bag for the response externally
+ *
+ * @param mixed $cookies
+ * @return Response
+ */
+ public function setCookies(\Phalcon\Http\Response\CookiesInterface $cookies) {}
+
+ /**
+ * Returns coookies set by the user
+ *
+ * @return \Phalcon\Http\Response\CookiesInterface
+ */
+ public function getCookies() {}
+
+ /**
+ * Overwrites a header in the response
+ *
+ * $response->setHeader("Content-Type", "text/plain");
+ *
+ *
+ * @param string $name
+ * @param string $value
+ * @return \Phalcon\Http\Response
+ */
+ public function setHeader($name, $value) {}
+
+ /**
+ * Send a raw header to the response
+ *
+ * $response->setRawHeader("HTTP/1.1 404 Not Found");
+ *
+ *
+ * @param string $header
+ * @return Response
+ */
+ public function setRawHeader($header) {}
+
+ /**
+ * Resets all the stablished headers
+ *
+ * @return Response
+ */
+ public function resetHeaders() {}
+
+ /**
+ * Sets a Expires header to use HTTP cache
+ *
+ * $this->response->setExpires(new DateTime());
+ *
+ *
+ * @param mixed $datetime
+ * @return Response
+ */
+ public function setExpires(\DateTime $datetime) {}
+
+ /**
+ * Sends a Not-Modified response
+ *
+ * @return Response
+ */
+ public function setNotModified() {}
+
+ /**
+ * Sets the response content-type mime, optionally the charset
+ *
+ * $response->setContentType('application/pdf');
+ * $response->setContentType('text/plain', 'UTF-8');
+ *
+ *
+ * @param string $contentType
+ * @param string $charset
+ * @return \Phalcon\Http\Response
+ */
+ public function setContentType($contentType, $charset = null) {}
+
+ /**
+ * Set a custom ETag
+ *
+ * $response->setEtag(md5(time()));
+ *
+ *
+ * @param string $etag
+ * @return Response
+ */
+ public function setEtag($etag) {}
+
+ /**
+ * Redirect by HTTP to another action or URL
+ *
+ * //Using a string redirect (internal/external)
+ * $response->redirect("posts/index");
+ * $response->redirect("http://en.wikipedia.org", true);
+ * $response->redirect("http://www.example.com/new-location", true, 301);
+ * //Making a redirection based on a named route
+ * $response->redirect(array(
+ * "for" => "index-lang",
+ * "lang" => "jp",
+ * "controller" => "index"
+ * ));
+ *
+ *
+ * @param string|array $location
+ * @param boolean $externalRedirect
+ * @param int $statusCode
+ * @return \Phalcon\Http\Response
+ */
+ public function redirect($location = null, $externalRedirect = false, $statusCode = 302) {}
+
+ /**
+ * Sets HTTP response body
+ *
+ * response->setContent("Hello!
");
+ *
+ *
+ * @param string $content
+ * @return Response
+ */
+ public function setContent($content) {}
+
+ /**
+ * Sets HTTP response body. The parameter is automatically converted to JSON
+ *
+ * $response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param mixed $content
+ * @param int $jsonOptions
+ * @return \Phalcon\Http\Response
+ */
+ public function setJsonContent($content, $jsonOptions = 0) {}
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\Response
+ */
+ public function appendContent($content) {}
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Check if the response is already sent
+ *
+ * @return bool
+ */
+ public function isSent() {}
+
+ /**
+ * Sends headers to the client
+ *
+ * @return Response
+ */
+ public function sendHeaders() {}
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return Response
+ */
+ public function sendCookies() {}
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return Response
+ */
+ public function send() {}
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @param mixed $attachment
+ * @return \Phalcon\Http\Response
+ */
+ public function setFileToSend($filePath, $attachmentName = null, $attachment = true) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/http/ResponseInterface.php b/ide/2.0.3/Phalcon/http/ResponseInterface.php
new file mode 100644
index 000000000..36f157f32
--- /dev/null
+++ b/ide/2.0.3/Phalcon/http/ResponseInterface.php
@@ -0,0 +1,150 @@
+
+ * response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function setJsonContent($content);
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function appendContent($content);
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent();
+
+ /**
+ * Sends headers to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendHeaders();
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendCookies();
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return ResponseInterface
+ */
+ public function send();
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @return ResponseInterface
+ */
+ public function setFileToSend($filePath, $attachmentName = null);
+
+}
diff --git a/ide/2.0.3/Phalcon/http/cookie/Exception.php b/ide/2.0.3/Phalcon/http/cookie/Exception.php
new file mode 100644
index 000000000..a3dbbd67d
--- /dev/null
+++ b/ide/2.0.3/Phalcon/http/cookie/Exception.php
@@ -0,0 +1,12 @@
+
+ * class PostsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function uploadAction()
+ * {
+ * //Check if the user has uploaded files
+ * if ($this->request->hasFiles() == true) {
+ * //Print the real file names and their sizes
+ * foreach ($this->request->getUploadedFiles() as $file){
+ * echo $file->getName(), " ", $file->getSize(), "\n";
+ * }
+ * }
+ * }
+ * }
+ *
+ */
+class File implements \Phalcon\Http\Request\FileInterface
+{
+
+ protected $_name;
+
+
+ protected $_tmp;
+
+
+ protected $_size;
+
+
+ protected $_type;
+
+
+ protected $_realType;
+
+
+ protected $_error;
+
+
+ protected $_key;
+
+
+ protected $_extension;
+
+
+
+ public function getError() {}
+
+
+ public function getKey() {}
+
+
+ public function getExtension() {}
+
+ /**
+ * Phalcon\Http\Request\File constructor
+ *
+ * @param array $file
+ * @param mixed $key
+ */
+ public function __construct($file, $key = null) {}
+
+ /**
+ * Returns the file size of the uploaded file
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Returns the real name of the uploaded file
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Returns the temporal name of the uploaded file
+ *
+ * @return string
+ */
+ public function getTempName() {}
+
+ /**
+ * Returns the mime type reported by the browser
+ * This mime type is not completely secure, use getRealType() instead
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Gets the real mime type of the upload file using finfo
+ *
+ * @return string
+ */
+ public function getRealType() {}
+
+ /**
+ * Checks whether the file has been uploaded via Post.
+ *
+ * @return bool
+ */
+ public function isUploadedFile() {}
+
+ /**
+ * Moves the temporary file to a destination within the application
+ *
+ * @param string $destination
+ * @return bool
+ */
+ public function moveTo($destination) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/http/request/FileInterface.php b/ide/2.0.3/Phalcon/http/request/FileInterface.php
new file mode 100644
index 000000000..3e3109e86
--- /dev/null
+++ b/ide/2.0.3/Phalcon/http/request/FileInterface.php
@@ -0,0 +1,64 @@
+
+ * $image = new Phalcon\Image\Adapter\Imagick("upload/test.jpg");
+ * $image->resize(200, 200)->rotate(90)->crop(100, 100);
+ * if ($image->save()) {
+ * echo 'success';
+ * }
+ *
+ */
+class Imagick extends \Phalcon\Image\Adapter implements \Phalcon\Image\AdapterInterface
+{
+
+ static protected $_version = 0;
+
+
+ static protected $_checked = false;
+
+
+ /**
+ * Checks if Imagick is enabled
+ *
+ * @return bool
+ */
+ public static function check() {}
+
+ /**
+ * \Phalcon\Image\Adapter\Imagick constructor
+ *
+ * @param string $file
+ * @param int $width
+ * @param int $height
+ */
+ public function __construct($file, $width = null, $height = null) {}
+
+ /**
+ * Execute a resize.
+ *
+ * @param int $width
+ * @param int $height
+ */
+ protected function _resize($width, $height) {}
+
+ /**
+ * This method scales the images using liquid rescaling method. Only support Imagick
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $deltaX
+ * @param int $rigidity
+ * @param int $$width new width
+ * @param int $$height new height
+ * @param int $$deltaX How much the seam can traverse on x-axis. Passing 0 causes the seams to be straight.
+ * @param int $$rigidity Introduces a bias for non-straight seams. This parameter is typically 0.
+ */
+ protected function _liquidRescale($width, $height, $deltaX, $rigidity) {}
+
+ /**
+ * Execute a crop.
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $offsetX
+ * @param int $offsetY
+ */
+ protected function _crop($width, $height, $offsetX, $offsetY) {}
+
+ /**
+ * Execute a rotation.
+ *
+ * @param int $degrees
+ */
+ protected function _rotate($degrees) {}
+
+ /**
+ * Execute a flip.
+ *
+ * @param int $direction
+ */
+ protected function _flip($direction) {}
+
+ /**
+ * Execute a sharpen.
+ *
+ * @param int $amount
+ */
+ protected function _sharpen($amount) {}
+
+ /**
+ * Execute a reflection.
+ *
+ * @param int $height
+ * @param int $opacity
+ * @param bool $fadeIn
+ */
+ protected function _reflection($height, $opacity, $fadeIn) {}
+
+ /**
+ * Execute a watermarking.
+ *
+ * @param mixed $image
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ */
+ protected function _watermark(\Phalcon\Image\Adapter $image, $offsetX, $offsetY, $opacity) {}
+
+ /**
+ * Execute a text
+ *
+ * @param string $text
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $size
+ * @param string $fontfile
+ */
+ protected function _text($text, $offsetX, $offsetY, $opacity, $r, $g, $b, $size, $fontfile) {}
+
+ /**
+ * Composite one image onto another
+ *
+ * @param mixed $image
+ * @param Adapter $$mask mask Image instance
+ */
+ protected function _mask(\Phalcon\Image\Adapter $image) {}
+
+ /**
+ * Execute a background.
+ *
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $opacity
+ */
+ protected function _background($r, $g, $b, $opacity) {}
+
+ /**
+ * Blur image
+ *
+ * @param int $radius
+ * @param int $$radius Blur radius
+ */
+ protected function _blur($radius) {}
+
+ /**
+ * Pixelate image
+ *
+ * @param int $amount
+ * @param int $$amount amount to pixelate
+ */
+ protected function _pixelate($amount) {}
+
+ /**
+ * Execute a save.
+ *
+ * @param string $file
+ * @param int $quality
+ */
+ protected function _save($file, $quality) {}
+
+ /**
+ * Execute a render.
+ *
+ * @param string $extension
+ * @param int $quality
+ * @return string
+ */
+ protected function _render($extension, $quality) {}
+
+ /**
+ * Destroys the loaded image to free up resources.
+ */
+ public function __destruct() {}
+
+ /**
+ * Get instance
+ *
+ * @return \Imagick
+ */
+ public function getInternalImInstance() {}
+
+ /**
+ * Sets the limit for a particular resource in megabytes
+ *
+ * @param int $type Refer to the list of resourcetype constants (@see http://php.net/manual/ru/imagick.constants.php#imagick.constants.resourcetypes.)
+ * @param int $limit The resource limit. The unit depends on the type of the resource being limited.
+ */
+ public function setResourceLimit($type, $limit) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/loader/Exception.php b/ide/2.0.3/Phalcon/loader/Exception.php
new file mode 100644
index 000000000..0732e2934
--- /dev/null
+++ b/ide/2.0.3/Phalcon/loader/Exception.php
@@ -0,0 +1,12 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ * $logger->close();
+ *
+ */
+class File extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_fileHandler;
+
+ /**
+ * File Path
+ */
+ protected $_path;
+
+ /**
+ * Path options
+ */
+ protected $_options;
+
+
+ /**
+ * File Path
+ */
+ public function getPath() {}
+
+ /**
+ * Phalcon\Logger\Adapter\File constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the file itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Opens the internal file handler after unserialization
+ */
+ public function __wakeup() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/logger/adapter/Firephp.php b/ide/2.0.3/Phalcon/logger/adapter/Firephp.php
new file mode 100644
index 000000000..8066f6805
--- /dev/null
+++ b/ide/2.0.3/Phalcon/logger/adapter/Firephp.php
@@ -0,0 +1,52 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Firephp("");
+ * $logger->log(\Phalcon\Logger::ERROR, "This is an error");
+ * $logger->error("This is another error");
+ *
+ */
+class Firephp extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ static private $_initialized;
+
+
+ static private $_index;
+
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @see http://www.firephp.org/Wiki/Reference/Protocol
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param string $$message
+ * @param int $$type
+ * @param int $$time
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/logger/adapter/Stream.php b/ide/2.0.3/Phalcon/logger/adapter/Stream.php
new file mode 100644
index 000000000..dd26d9015
--- /dev/null
+++ b/ide/2.0.3/Phalcon/logger/adapter/Stream.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Stream("php://stderr");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Stream extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_stream;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Stream constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/logger/adapter/Syslog.php b/ide/2.0.3/Phalcon/logger/adapter/Syslog.php
new file mode 100644
index 000000000..cc0eb1569
--- /dev/null
+++ b/ide/2.0.3/Phalcon/logger/adapter/Syslog.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Syslog("ident", array(
+ * 'option' => LOG_NDELAY,
+ * 'facility' => LOG_MAIL
+ * ));
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Syslog extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ protected $_opened = false;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Syslog constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\Formatter\Syslog
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return boolean
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/logger/formatter/Firephp.php b/ide/2.0.3/Phalcon/logger/formatter/Firephp.php
new file mode 100644
index 000000000..567c7aee9
--- /dev/null
+++ b/ide/2.0.3/Phalcon/logger/formatter/Firephp.php
@@ -0,0 +1,71 @@
+
+ * class Application extends \Phalcon\Mvc\Application
+ * {
+ * /
+ * Register the services here to make them general or register
+ * in the ModuleDefinition to make them module-specific
+ * \/
+ * protected function _registerServices()
+ * {
+ * }
+ * /
+ * This method registers all the modules in the application
+ * \/
+ * public function main()
+ * {
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ * }
+ * }
+ * $application = new Application();
+ * $application->main();
+ *
+ */
+class Application extends \Phalcon\Di\Injectable
+{
+
+ protected $_defaultModule;
+
+
+ protected $_modules;
+
+
+ protected $_implicitView = true;
+
+
+ /**
+ * Phalcon\Mvc\Application
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * By default. The view is implicitly buffering all the output
+ * You can full disable the view component using this method
+ *
+ * @param bool $implicitView
+ * @return Application
+ */
+ public function useImplicitView($implicitView) {}
+
+ /**
+ * Register an array of modules present in the application
+ *
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ * @param bool $merge
+ * @return Application
+ */
+ public function registerModules($modules, $merge = false) {}
+
+ /**
+ * Return the modules registered in the application
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Gets the module definition registered in the application via module name
+ *
+ * @param string $name
+ * @return array|object
+ */
+ public function getModule($name) {}
+
+ /**
+ * Sets the module name to be used if the router doesn't return a valid module
+ *
+ * @param string $defaultModule
+ * @return Application
+ */
+ public function setDefaultModule($defaultModule) {}
+
+ /**
+ * Returns the default module name
+ *
+ * @return string
+ */
+ public function getDefaultModule() {}
+
+ /**
+ * Handles a MVC request
+ *
+ * @param string $uri
+ * @return \Phalcon\Http\ResponseInterface|boolean
+ */
+ public function handle($uri = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/Collection.php b/ide/2.0.3/Phalcon/mvc/Collection.php
new file mode 100644
index 000000000..a68d10253
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/Collection.php
@@ -0,0 +1,509 @@
+
+ * echo robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns a cloned collection
+ *
+ * @param mixed $collection
+ * @param array $document
+ * @return CollectionInterface
+ */
+ public static function cloneResult(CollectionInterface $collection, $document) {}
+
+ /**
+ * Returns a collection resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @param boolean $unique
+ * @return array
+ */
+ protected static function _getResultset($params, CollectionInterface $collection, $connection, $unique) {}
+
+ /**
+ * Perform a count over a resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @return int
+ */
+ protected static function _getGroupResultset($params, Collection $collection, $connection) {}
+
+ /**
+ * Executes internal hooks before save a document
+ *
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @param boolean $disableEvents
+ * @param boolean $exists
+ * @return boolean
+ */
+ protected final function _preSave($dependencyInjector, $disableEvents, $exists) {}
+
+ /**
+ * Executes internal events after save a document
+ *
+ * @param bool $disableEvents
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected final function _postSave($disableEvents, $success, $exists) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Fires an internal event
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an internal event that cancels the operation
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ *
+ * @param bool $disableEvents
+ * @return bool
+ */
+ protected function _cancelOperation($disableEvents) {}
+
+ /**
+ * Checks if the document exists in the collection
+ *
+ * @param \MongoCollection $collection
+ * @return boolean
+ */
+ protected function _exists($collection) {}
+
+ /**
+ * Returns all the validation messages
+ *
+ * robot = new Robots();
+ * robot->type = 'mechanical';
+ * robot->name = 'Astro Boy';
+ * robot->year = 1952;
+ * if (robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach (robot->getMessages() as message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if (this->name == 'Peter') {
+ * message = new Message("Sorry, but a robot cannot be named Peter");
+ * this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Creates/Updates a collection based on the values in the atributes
+ *
+ * @return bool
+ */
+ public function save() {}
+
+ /**
+ * Find a document by its id (_id)
+ *
+ * @param string|\MongoId $id
+ * @return \Phalcon\Mvc\Collection
+ */
+ public static function findById($id) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in the robots table?
+ * robot = Robots::findFirst();
+ * echo "The robot name is ", robot->name, "\n";
+ * //What's the first mechanical robot in robots table?
+ * robot = Robots::findFirst(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "The first mechanical robot name is ", robot->name, "\n";
+ * //Get first virtual robot ordered by name
+ * robot = Robots::findFirst(array(
+ * array("type" => "mechanical"),
+ * "order" => array("name" => 1)
+ * ));
+ * echo "The first virtual robot name is ", robot->name, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+ * robots = Robots::find();
+ * echo "There are ", count(robots), "\n";
+ * //How many mechanical robots are there?
+ * robots = Robots::find(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "There are ", count(robots), "\n";
+ * //Get and print virtual robots ordered by name
+ * robots = Robots::findFirst(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1)
+ * ));
+ * foreach (robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * robots = Robots::find(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1),
+ * "limit" => 100
+ * ));
+ * foreach (robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Perform a count over a collection
+ *
+ * echo 'There are ', Robots::count(), ' robots';
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Perform an aggregation using the Mongo aggregation framework
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function aggregate($parameters = null) {}
+
+ /**
+ * Allows to perform a summatory group for a column in the collection
+ *
+ * @param string $field
+ * @param array $conditions
+ * @param string $finalize
+ * @return array
+ */
+ public static function summatory($field, $conditions = null, $finalize = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ * robot = Robots::findFirst();
+ * robot->delete();
+ * foreach (Robots::find() as robot) {
+ * robot->delete();
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r(robot->to[]);
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Serializes the object ignoring connections or protected properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+ /**
+ * Sets up a behavior in a collection
+ *
+ * @param mixed $behavior
+ */
+ protected function addBehavior(\Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/CollectionInterface.php b/ide/2.0.3/Phalcon/mvc/CollectionInterface.php
new file mode 100644
index 000000000..776a9aa36
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/CollectionInterface.php
@@ -0,0 +1,164 @@
+
+ * dispatcher->forward(array('controller' => 'people', 'action' => 'index'));
+ * }
+ * }
+ *
+ */
+abstract class Controller extends \Phalcon\Di\Injectable
+{
+
+ /**
+ * Phalcon\Mvc\Controller constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/ControllerInterface.php b/ide/2.0.3/Phalcon/mvc/ControllerInterface.php
new file mode 100644
index 000000000..a46083149
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/ControllerInterface.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Mvc\Dispatcher();
+ * $dispatcher->setDI($di);
+ * $dispatcher->setControllerName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $controller = $dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher implements \Phalcon\Mvc\DispatcherInterface
+{
+
+ protected $_handlerSuffix = "Controller";
+
+
+ protected $_defaultHandler = "index";
+
+
+ protected $_defaultAction = "index";
+
+
+ /**
+ * Sets the default controller suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the controller name to be dispatched
+ *
+ * @param string $controllerName
+ */
+ public function setControllerName($controllerName) {}
+
+ /**
+ * Gets last dispatched controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets previous dispatched controller name
+ *
+ * @return string
+ */
+ public function getPreviousControllerName() {}
+
+ /**
+ * Gets previous dispatched action name
+ *
+ * @return string
+ */
+ public function getPreviousActionName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Possible controller class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getControllerClass() {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getLastController() {}
+
+ /**
+ * Returns the active controller in the dispatcher
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getActiveController() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/DispatcherInterface.php b/ide/2.0.3/Phalcon/mvc/DispatcherInterface.php
new file mode 100644
index 000000000..d232517a7
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/DispatcherInterface.php
@@ -0,0 +1,54 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $app->get('/say/welcome/{name}', function ($name) {
+ * echo "
+ * $app['request'] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $alias
+ * @param mixed $definition
+ */
+ public function offsetSet($alias, $definition) {}
+
+ /**
+ * Allows to obtain a shared service in the internal services container using the array syntax
+ *
+ * var_dump($di['request']);
+ *
+ *
+ * @param string $alias
+ * @return mixed
+ */
+ public function offsetGet($alias) {}
+
+ /**
+ * Removes a service from the internal services container using the array syntax
+ *
+ * @param string $alias
+ */
+ public function offsetUnset($alias) {}
+
+ /**
+ * Appends a before middleware to be called before execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function before($handler) {}
+
+ /**
+ * Appends an 'after' middleware to be called after execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function after($handler) {}
+
+ /**
+ * Appends a 'finish' middleware to be called when the request is finished
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function finish($handler) {}
+
+ /**
+ * Returns the internal handlers attached to the application
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/Model.php b/ide/2.0.3/Phalcon/mvc/Model.php
new file mode 100644
index 000000000..07d3d14cf
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/Model.php
@@ -0,0 +1,1192 @@
+Phalcon\Mvc\Model connects business objects and database tables to create
+ * a persistable domain model where logic and data are presented in one wrapping.
+ * It‘s an implementation of the object-relational mapping (ORM).
+ * A model represents the information (data) of the application and the rules to manipulate that data. + * Models are primarily used for managing the rules of interaction with a corresponding database table. + * In most cases, each table in your database will correspond to one model in your application. + * The bulk of your application's business logic will be concentrated in the models.
+ *Phalcon\Mvc\Model is the first ORM written in C-language for PHP, giving to developers high performance + * when interacting with databases while is also easy to use.
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can store robots: ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ */
+abstract class Model implements \Phalcon\Mvc\ModelInterface, \Phalcon\Mvc\Model\ResultInterface, \Phalcon\Di\InjectionAwareInterface, \Serializable
+{
+
+ const OP_NONE = 0;
+
+
+ const OP_CREATE = 1;
+
+
+ const OP_UPDATE = 2;
+
+
+ const OP_DELETE = 3;
+
+
+ const DIRTY_STATE_PERSISTENT = 0;
+
+
+ const DIRTY_STATE_TRANSIENT = 1;
+
+
+ const DIRTY_STATE_DETACHED = 2;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_modelsManager;
+
+
+ protected $_modelsMetaData;
+
+
+ protected $_errorMessages;
+
+
+ protected $_operationMade = 0;
+
+
+ protected $_dirtyState = 1;
+
+
+ protected $_transaction;
+
+
+ protected $_uniqueKey;
+
+
+ protected $_uniqueParams;
+
+
+ protected $_uniqueTypes;
+
+
+ protected $_skipped;
+
+
+ protected $_related;
+
+
+ protected $_snapshot;
+
+
+ /**
+ * Phalcon\Mvc\Model constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param mixed $modelsManager
+ */
+ public final function __construct(\Phalcon\DiInterface $dependencyInjector = null, \Phalcon\Mvc\Model\ManagerInterface $modelsManager = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a custom events manager
+ *
+ * @param mixed $eventsManager
+ */
+ protected function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the custom events manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ protected function getEventsManager() {}
+
+ /**
+ * Returns the models meta-data service related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\MetaDataInterface
+ */
+ public function getModelsMetaData() {}
+
+ /**
+ * Returns the models manager related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\ManagerInterface
+ */
+ public function getModelsManager() {}
+
+ /**
+ * Sets a transaction related to the Model instance
+ *
+ * use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
+ * use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
+ * try {
+ * $txManager = new TxManager();
+ * $transaction = $txManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Robot part cannot be saved");
+ * }
+ * $transaction->commit();
+ * } catch (TxFailed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ *
+ * @param mixed $transaction
+ * @return Model
+ */
+ public function setTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Sets table name which model should be mapped
+ *
+ * @param string $source
+ * @return Model
+ */
+ protected function setSource($source) {}
+
+ /**
+ * Returns table name mapped in the model
+ *
+ * @return string
+ */
+ public function getSource() {}
+
+ /**
+ * Sets schema name where table mapped is located
+ *
+ * @param string $schema
+ * @return Model
+ */
+ protected function setSchema($schema) {}
+
+ /**
+ * Returns schema name where table mapped is located
+ *
+ * @return string
+ */
+ public function getSchema() {}
+
+ /**
+ * Sets the DependencyInjection connection service name
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to read data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setReadConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to write data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setWriteConnectionService($connectionService) {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to read data related the model
+ *
+ * @return string
+ */
+ public function getReadConnectionService() {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to write data related to the model
+ *
+ * @return string
+ */
+ public function getWriteConnectionService() {}
+
+ /**
+ * Sets the dirty state of the object using one of the DIRTY_STATE_* constants
+ *
+ * @param int $dirtyState
+ * @return ModelInterface
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not
+ *
+ * @return int
+ */
+ public function getDirtyState() {}
+
+ /**
+ * Gets the connection used to read data for the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection() {}
+
+ /**
+ * Gets the connection used to write data to the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection() {}
+
+ /**
+ * Assigns values to a model from an array
+ *
+ * $robot->assign(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ * //assign by db row, column map needed
+ * $robot->assign($dbRow, array(
+ * 'db_type' => 'type',
+ * 'db_name' => 'name',
+ * 'db_year' => 'year'
+ * ));
+ * //allow assign only name and year
+ * $robot->assign($_POST, null, array('name', 'year');
+ *
+ *
+ * @param array $data
+ * @param array $dataColumnMap array to transform keys of data to another
+ * @param array $whiteList
+ * @return \Phalcon\Mvc\Model
+ */
+ public function assign($data, $dataColumnMap = null, $whiteList = null) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model.
+ *
+ * $robot = \Phalcon\Mvc\Model::cloneResultMap(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface|\Phalcon\Mvc\Model\Row $base
+ * @param array $data
+ * @param array $columnMap
+ * @param int $dirtyState
+ * @param boolean $keepSnapshots
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function cloneResultMap($base, $data, $columnMap, $dirtyState = 0, $keepSnapshots = null) {}
+
+ /**
+ * Returns an hydrated result based on the data and the column map
+ *
+ * @param array $data
+ * @param array $columnMap
+ * @param int $hydrationMode
+ * @return mixed
+ */
+ public static function cloneResultMapHydrate($data, $columnMap, $hydrationMode) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model
+ *
+ * $robot = Phalcon\Mvc\Model::cloneResult(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param mixed $base
+ * @param array $data
+ * @param int $dirtyState
+ * @param \Phalcon\Mvc\ModelInterface $$base
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public static function cloneResult(ModelInterface $base, $data, $dirtyState = 0) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ * //How many mechanical robots are there?
+ * $robots = Robots::find("type='mechanical'");
+ * echo "There are ", count($robots), "\n";
+ * //Get and print virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name", "limit" => 100));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ *
+ * @param mixed $parameters
+ * @param $array parameters
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in robots table?
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name;
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst("type='mechanical'");
+ * echo "The first mechanical robot name is ", $robot->name;
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array("type='virtual'", "order" => "name"));
+ * echo "The first virtual robot name is ", $robot->name;
+ *
+ *
+ * @param array $parameters
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Create a criteria for a specific model
+ *
+ * @param mixed $dependencyInjector
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public static function query(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Checks if the current record already exists or not
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _exists(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table = null) {}
+
+ /**
+ * Generate a PHQL SELECT statement for an aggregate
+ *
+ * @param string $functionName
+ * @param string $alias
+ * @param array $parameters
+ * @param string $function
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected static function _groupResult($functionName, $alias, $parameters) {}
+
+ /**
+ * Allows to count how many records match the specified conditions
+ *
+ * //How many robots are there?
+ * $number = Robots::count();
+ * echo "There are ", $number, "\n";
+ * //How many mechanical robots are there?
+ * $number = Robots::count("type='mechanical'");
+ * echo "There are ", $number, " mechanical robots\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Allows to calculate a summatory on a column that match the specified conditions
+ *
+ * //How much are all robots?
+ * $sum = Robots::sum(array('column' => 'price'));
+ * echo "The total price of robots is ", $sum, "\n";
+ * //How much are mechanical robots?
+ * $sum = Robots::sum(array("type='mechanical'", 'column' => 'price'));
+ * echo "The total price of mechanical robots is ", $sum, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function sum($parameters = null) {}
+
+ /**
+ * Allows to get the maximum value of a column that match the specified conditions
+ *
+ * //What is the maximum robot id?
+ * $id = Robots::maximum(array('column' => 'id'));
+ * echo "The maximum robot id is: ", $id, "\n";
+ * //What is the maximum id of mechanical robots?
+ * $sum = Robots::maximum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The maximum robot id of mechanical robots is ", $id, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function maximum($parameters = null) {}
+
+ /**
+ * Allows to get the minimum value of a column that match the specified conditions
+ *
+ * //What is the minimum robot id?
+ * $id = Robots::minimum(array('column' => 'id'));
+ * echo "The minimum robot id is: ", $id;
+ * //What is the minimum id of mechanical robots?
+ * $sum = Robots::minimum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The minimum robot id of mechanical robots is ", $id;
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function minimum($parameters = null) {}
+
+ /**
+ * Allows to calculate the average value on a column matching the specified conditions
+ *
+ * //What's the average price of robots?
+ * $average = Robots::average(array('column' => 'price'));
+ * echo "The average price is ", $average, "\n";
+ * //What's the average price of mechanical robots?
+ * $average = Robots::average(array("type='mechanical'", 'column' => 'price'));
+ * echo "The average price of mechanical robots is ", $average, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return double
+ */
+ public static function average($parameters = null) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ * This method stops if one of the callbacks/listeners returns boolean false
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ */
+ protected function _cancelOperation() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if ($this->name == 'Peter') {
+ * $message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage($message);
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ * @return Model
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ * @return Model
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Returns all the validation messages
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo $message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @param mixed $filter
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages($filter = null) {}
+
+ /**
+ * Reads "belongs to" relations and check the virtual foreign keys when inserting or updating records
+ * to verify that inserted/updated values are present in the related entity
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysRestrict() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (cascade) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseCascade() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (restrict) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseRestrict() {}
+
+ /**
+ * Executes internal hooks before save a record
+ *
+ * @param mixed $metaData
+ * @param bool $exists
+ * @param mixed $identityField
+ * @return bool
+ */
+ protected function _preSave(\Phalcon\Mvc\Model\MetadataInterface $metaData, $exists, $identityField) {}
+
+ /**
+ * Executes internal events after save a record
+ *
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected function _postSave($success, $exists) {}
+
+ /**
+ * Sends a pre-build INSERT SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @param boolean|string $identityField
+ * @return boolean
+ */
+ protected function _doLowInsert(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table, $identityField) {}
+
+ /**
+ * Sends a pre-build UPDATE SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetaDataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _doLowUpdate(\Phalcon\Mvc\Model\MetaDataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table) {}
+
+ /**
+ * Saves related records that must be stored prior to save the master record
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _preSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Save the related records assigned in the has-one/has-many relations
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _postSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Inserts or updates a model instance. Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->save();
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->save();
+ *
+ *
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+ */
+ public function save($data = null, $whiteList = null) {}
+
+ /**
+ * Inserts a model instance. If the instance already exists in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->create();
+ * //Passing an array to create
+ * $robot = new Robots();
+ * $robot->create(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astroy Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+ */
+ public function create($data = null, $whiteList = null) {}
+
+ /**
+ * Updates a model instance. If the instance doesn't exist in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->update();
+ *
+ *
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+ */
+ public function update($data = null, $whiteList = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ * $robot = Robots::findFirst("id=100");
+ * $robot->delete();
+ * foreach (Robots::find("type = 'mechanical'") as $robot) {
+ * $robot->delete();
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+ * Returns the type of the latest operation performed by the ORM
+ * Returns one of the OP_* class constants
+ *
+ * @return int
+ */
+ public function getOperationMade() {}
+
+ /**
+ * Refreshes the model attributes re-querying the record from the database
+ *
+ * @return Model
+ */
+ public function refresh() {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT/UPDATE statement
+ *
+ * skipAttributes(array('price'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributes($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT statement
+ *
+ * skipAttributesOnCreate(array('created_at'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnCreate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * skipAttributesOnUpdate(array('modified_in'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnUpdate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * allowEmptyStringValues(array('name'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function allowEmptyStringValues($attributes) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * hasOne('id', 'RobotsDescription', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasOne($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse 1-1 between two models
+ *
+ * belongsTo('robots_id', 'Robots', 'id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function belongsTo($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * hasMany('id', 'RobotsParts', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasMany($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation n-n between two models through an intermediate relation
+ *
+ * hasManyToMany(
+ * 'id',
+ * 'RobotsParts',
+ * 'robots_id',
+ * 'parts_id',
+ * 'Parts',
+ * 'id'
+ * );
+ * }
+ * }
+ *
+ *
+ * @param string|array fields
+ * @param string intermediateModel
+ * @param string|array intermediateFields
+ * @param string|array intermediateReferencedFields
+ * @param string referencedModel
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referenceModel
+ * @param string|array $referencedFields
+ * @param array $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasManyToMany($fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a behavior in a model
+ *
+ * addBehavior(new Timestampable(array(
+ * 'onCreate' => array(
+ * 'field' => 'created_at',
+ * 'format' => 'Y-m-d'
+ * )
+ * )));
+ * }
+ * }
+ *
+ *
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if the model must keep the original record snapshot in memory
+ *
+ * keepSnapshots(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $keepSnapshot
+ */
+ protected function keepSnapshots($keepSnapshot) {}
+
+ /**
+ * Sets the record's snapshot data.
+ * This method is used internally to set snapshot data when the model was set up to keep snapshot data
+ *
+ * @param array $data
+ * @param array $columnMap
+ */
+ public function setSnapshotData($data, $columnMap = null) {}
+
+ /**
+ * Checks if the object has internal snapshot data
+ *
+ * @return bool
+ */
+ public function hasSnapshotData() {}
+
+ /**
+ * Returns the internal snapshot data
+ *
+ * @return array
+ */
+ public function getSnapshotData() {}
+
+ /**
+ * Check if a specific attribute has changed
+ * This only works if the model is keeping data snapshots
+ *
+ * @param string|array $fieldName
+ * @return bool
+ */
+ public function hasChanged($fieldName = null) {}
+
+ /**
+ * Returns a list of changed values
+ *
+ * @return array
+ */
+ public function getChangedFields() {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * useDynamicUpdate(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $dynamicUpdate
+ */
+ protected function useDynamicUpdate($dynamicUpdate) {}
+
+ /**
+ * Returns related records based on defined relations
+ *
+ * @param string $alias
+ * @param array $arguments
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getRelated($alias, $arguments = null) {}
+
+ /**
+ * Returns related records defined relations depending on the method name
+ *
+ * @param string $modelName
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ protected function _getRelatedRecords($modelName, $method, $arguments) {}
+
+ /**
+ * Handles method calls when a method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+ public function __call($method, $arguments = null) {}
+
+ /**
+ * Handles method calls when a static method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+ public static function __callStatic($method, $arguments = null) {}
+
+ /**
+ * Magic method to assign values to the the model
+ *
+ * @param string $property
+ * @param mixed $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Magic method to get related records using the relation alias as a property
+ *
+ * @param string $property
+ * @return \Phalcon\Mvc\Model\Resultset|\Phalcon\Mvc\Model
+ */
+ public function __get($property) {}
+
+ /**
+ * Magic method to check if a property is a valid relation
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Serializes the object ignoring connections, services, related objects or static properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+ /**
+ * Returns a simple representation of the object that can be used with var_dump
+ *
+ * var_dump($robot->dump());
+ *
+ *
+ * @return array
+ */
+ public function dump() {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r($robot->toArray());
+ *
+ *
+ * @param mixed $columns
+ * @param array $$columns
+ * @return array
+ */
+ public function toArray($columns = null) {}
+
+ /**
+ * Enables/disables options in the ORM
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+ /**
+ * Reset a model instance data
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/ModelInterface.php b/ide/2.0.3/Phalcon/mvc/ModelInterface.php
new file mode 100644
index 000000000..ad17cec83
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/ModelInterface.php
@@ -0,0 +1,339 @@
+Phalcon\Mvc\Router is the standard framework router. Routing is the
+ * process of taking a URI endpoint (that part of the URI which comes after the base URL) and
+ * decomposing it into parameters to determine which module, controller, and
+ * action of that controller should receive the request
+ *
+ * $router = new Router();
+ * $router->add(
+ * "/documentation/{chapter}/{name}.{type:[a-z]+}",
+ * array(
+ * "controller" => "documentation",
+ * "action" => "show"
+ * )
+ * );
+ * $router->handle();
+ * echo $router->getControllerName();
+ *
+ */
+class Router implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\RouterInterface
+{
+
+ const URI_SOURCE_GET_URL = 0;
+
+
+ const URI_SOURCE_SERVER_REQUEST_URI = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_uriSource;
+
+
+ protected $_namespace = null;
+
+
+ protected $_module = null;
+
+
+ protected $_controller = null;
+
+
+ protected $_action = null;
+
+
+ protected $_params;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ protected $_defaultNamespace;
+
+
+ protected $_defaultModule;
+
+
+ protected $_defaultController;
+
+
+ protected $_defaultAction;
+
+
+ protected $_defaultParams;
+
+
+ protected $_removeExtraSlashes;
+
+
+ protected $_notFoundPaths;
+
+
+ /**
+ * Phalcon\Mvc\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Get rewrite info. This info is read from $_GET['_url']. This returns '/' if the rewrite information cannot be read
+ *
+ * @return string
+ */
+ public function getRewriteUri() {}
+
+ /**
+ * Sets the URI source. One of the URI_SOURCE_* constants
+ *
+ * $router->setUriSource(Router::URI_SOURCE_SERVER_REQUEST_URI);
+ *
+ *
+ * @param mixed $uriSource
+ * @return RouterInterface
+ */
+ public function setUriSource($uriSource) {}
+
+ /**
+ * Set whether router must remove the extra slashes in the handled routes
+ *
+ * @param bool $remove
+ * @return RouterInterface
+ */
+ public function removeExtraSlashes($remove) {}
+
+ /**
+ * Sets the name of the default namespace
+ *
+ * @param string $namespaceName
+ * @return RouterInterface
+ */
+ public function setDefaultNamespace($namespaceName) {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ * @return RouterInterface
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ * @return RouterInterface
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ * @return RouterInterface
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return RouterInterface
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Returns an array of default parameters
+ *
+ * @return array
+ */
+ public function getDefaults() {}
+
+ /**
+ * Handles routing information received from the rewrite engine
+ *
+ * //Read the info from the rewrite engine
+ * $router->handle();
+ * //Manually passing an URL
+ * $router->handle('/posts/edit/1');
+ *
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Adds a route to the router without any HTTP constraint
+ *
+ * $router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null) {}
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null) {}
+
+ /**
+ * Mounts a group of routes in the router
+ *
+ * @param mixed $group
+ * @return RouterInterface
+ */
+ public function mount(\Phalcon\Mvc\Router\GroupInterface $group) {}
+
+ /**
+ * Set a group of paths to be returned when none of the defined routes are matched
+ *
+ * @param mixed $paths
+ * @return RouterInterface
+ */
+ public function notFound($paths) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Returns the processed namespace name
+ *
+ * @return string
+ */
+ public function getNamespaceName() {}
+
+ /**
+ * Returns the processed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns the processed controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Returns the processed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns the processed parameters
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param mixed $id
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteByName($name) {}
+
+ /**
+ * Returns whether controller name should not be mangled
+ *
+ * @return bool
+ */
+ public function isExactControllerName() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/RouterInterface.php b/ide/2.0.3/Phalcon/mvc/RouterInterface.php
new file mode 100644
index 000000000..d649f3afb
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/RouterInterface.php
@@ -0,0 +1,212 @@
+
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ */
+class Url implements \Phalcon\Mvc\UrlInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_baseUri = null;
+
+
+ protected $_staticBaseUri = null;
+
+
+ protected $_basePath = null;
+
+
+ protected $_router;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a prefix for all the URIs to be generated
+ *
+ * $url->setBaseUri('/invo/');
+ * $url->setBaseUri('/invo/index.php/');
+ *
+ *
+ * @param string $baseUri
+ * @return Url
+ */
+ public function setBaseUri($baseUri) {}
+
+ /**
+ * Sets a prefix for all static URLs generated
+ *
+ * $url->setStaticBaseUri('/invo/');
+ *
+ *
+ * @param string $staticBaseUri
+ * @return Url
+ */
+ public function setStaticBaseUri($staticBaseUri) {}
+
+ /**
+ * Returns the prefix for all the generated urls. By default /
+ *
+ * @return string
+ */
+ public function getBaseUri() {}
+
+ /**
+ * Returns the prefix for all the generated static urls. By default /
+ *
+ * @return string
+ */
+ public function getStaticBaseUri() {}
+
+ /**
+ * Sets a base path for all the generated paths
+ *
+ * $url->setBasePath('/var/www/htdocs/');
+ *
+ *
+ * @param string $basePath
+ * @return Url
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Returns the base path
+ *
+ * @return string
+ */
+ public function getBasePath() {}
+
+ /**
+ * Generates a URL
+ *
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ *
+ * @param string|array $uri
+ * @param array|object $args Optional arguments to be appended to the query string
+ * @param bool $local
+ * @param bool $$local
+ * @return string
+ */
+ public function get($uri = null, $args = null, $local = null) {}
+
+ /**
+ * Generates a URL for a static resource
+ *
+ * @param string|array $uri
+ * @return string
+ */
+ public function getStatic($uri = null) {}
+
+ /**
+ * Generates a local path
+ *
+ * @param string $path
+ * @return string
+ */
+ public function path($path = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/UrlInterface.php b/ide/2.0.3/Phalcon/mvc/UrlInterface.php
new file mode 100644
index 000000000..9d35e888c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/UrlInterface.php
@@ -0,0 +1,59 @@
+
+ * //Setting views directory
+ * $view = new \Phalcon\Mvc\View();
+ * $view->setViewsDir('app/views/');
+ * $view->start();
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->render('posts', 'recent');
+ * $view->finish();
+ * //Printing views output
+ * echo $view->getContent();
+ *
+ */
+class View extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewInterface
+{
+ /**
+ * Render Level: To the main layout
+ */
+ const LEVEL_MAIN_LAYOUT = 5;
+
+ /**
+ * Render Level: Render to the templates "after"
+ */
+ const LEVEL_AFTER_TEMPLATE = 4;
+
+ /**
+ * Render Level: Hasta el layout del controlador
+ */
+ const LEVEL_LAYOUT = 3;
+
+ /**
+ * Render Level: To the templates "before"
+ */
+ const LEVEL_BEFORE_TEMPLATE = 2;
+
+ /**
+ * Render Level: To the action view
+ */
+ const LEVEL_ACTION_VIEW = 1;
+
+ /**
+ * Render Level: No render any view
+ */
+ const LEVEL_NO_RENDER = 0;
+
+ /**
+ * Cache Mode
+ */
+ const CACHE_MODE_NONE = 0;
+
+
+ const CACHE_MODE_INVERSE = 1;
+
+
+ protected $_options;
+
+
+ protected $_basePath = "";
+
+
+ protected $_content = "";
+
+
+ protected $_renderLevel = 5;
+
+
+ protected $_currentRenderLevel = 0;
+
+
+ protected $_disabledLevels;
+
+
+ protected $_viewParams;
+
+
+ protected $_layout;
+
+
+ protected $_layoutsDir = "";
+
+
+ protected $_partialsDir = "";
+
+
+ protected $_viewsDir;
+
+
+ protected $_templatesBefore;
+
+
+ protected $_templatesAfter;
+
+
+ protected $_engines = false;
+
+
+ protected $_registeredEngines;
+
+
+ protected $_mainView = "index";
+
+
+ protected $_controllerName;
+
+
+ protected $_actionName;
+
+
+ protected $_params;
+
+
+ protected $_pickView;
+
+
+ protected $_cache;
+
+
+ protected $_cacheLevel = 0;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_disabled = false;
+
+
+
+ public function getRenderLevel() {}
+
+
+ public function getCurrentRenderLevel() {}
+
+
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ * @return View
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setLayoutsDir('../common/layouts/');
+ *
+ *
+ * @param string $layoutsDir
+ * @return View
+ */
+ public function setLayoutsDir($layoutsDir) {}
+
+ /**
+ * Gets the current layouts sub-directory
+ *
+ * @return string
+ */
+ public function getLayoutsDir() {}
+
+ /**
+ * Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setPartialsDir('../common/partials/');
+ *
+ *
+ * @param string $partialsDir
+ * @return View
+ */
+ public function setPartialsDir($partialsDir) {}
+
+ /**
+ * Gets the current partials sub-directory
+ *
+ * @return string
+ */
+ public function getPartialsDir() {}
+
+ /**
+ * Sets base path. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setBasePath(__DIR__ . '/');
+ *
+ *
+ * @param string $basePath
+ * @return View
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Sets the render level for the view
+ *
+ * //Render the view related to the controller only
+ * $this->view->setRenderLevel(View::LEVEL_VIEW);
+ *
+ *
+ * @param int $level
+ * @return View
+ */
+ public function setRenderLevel($level) {}
+
+ /**
+ * Disables a specific level of rendering
+ *
+ * //Render all levels except ACTION level
+ * $this->view->disableLevel(View::LEVEL_ACTION_VIEW);
+ *
+ *
+ * @param int|array $level
+ * @return \Phalcon\Mvc\View
+ */
+ public function disableLevel($level) {}
+
+ /**
+ * Sets default view name. Must be a file without extension in the views directory
+ *
+ * //Renders as main view views-dir/base.phtml
+ * $this->view->setMainView('base');
+ *
+ *
+ * @param string $viewPath
+ * @return View
+ */
+ public function setMainView($viewPath) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getMainView() {}
+
+ /**
+ * Change the layout to be used instead of using the name of the latest controller name
+ *
+ * $this->view->setLayout('main');
+ *
+ *
+ * @param string $layout
+ * @return View
+ */
+ public function setLayout($layout) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getLayout() {}
+
+ /**
+ * Sets a template before the controller layout
+ *
+ * @param string|array $templateBefore
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateBefore($templateBefore) {}
+
+ /**
+ * Resets any "template before" layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateBefore() {}
+
+ /**
+ * Sets a "template after" controller layout
+ *
+ * @param string|array $templateAfter
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateAfter($templateAfter) {}
+
+ /**
+ * Resets any template before layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateAfter() {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param boolean $merge
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Gets the name of the controller rendered
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets the name of the action rendered
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Gets extra parameters of the action rendered
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Starts rendering process enabling the output buffering
+ *
+ * @return View
+ */
+ public function start() {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Checks whether view exists on registered extensions and render it
+ *
+ * @param array $engines
+ * @param string $viewPath
+ * @param boolean $silence
+ * @param boolean $mustClean
+ * @param mixed $cache
+ * @param \Phalcon\Cache\BackendInterface $$cache
+ */
+ protected function _engineRender($engines, $viewPath, $silence, $mustClean, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ * @return View
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Checks whether view exists
+ *
+ * @param string $view
+ * @return bool
+ */
+ public function exists($view) {}
+
+ /**
+ * Executes render process from dispatching data
+ *
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->start()->render('posts', 'recent')->finish();
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @return bool|View
+ */
+ public function render($controllerName, $actionName, $params = null) {}
+
+ /**
+ * Choose a different view to render instead of last-controller/last-action
+ *
+ * class ProductsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function saveAction()
+ * {
+ * //Do some save stuff...
+ * //Then show the list view
+ * $this->view->pick("products/list");
+ * }
+ * }
+ *
+ *
+ * @param string|array $renderView
+ * @return \Phalcon\Mvc\View
+ */
+ public function pick($renderView) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Retrieve the contents of a partial
+ * echo $this->getPartial('shared/footer');
+ *
+ *
+ * //Retrieve the contents of a partial with arguments
+ * echo $this->getPartial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ * @return string
+ */
+ public function getPartial($partialPath, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Perform the automatic rendering returning the output as a string
+ *
+ * $template = $this->view->getRender('products', 'show', array('products' => $products));
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @param mixed $configCallback
+ * @return string
+ */
+ public function getRender($controllerName, $actionName, $params = null, $configCallback = null) {}
+
+ /**
+ * Finishes the render process by stopping the output buffering
+ *
+ * @return View
+ */
+ public function finish() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Check if the component is currently caching the output content
+ *
+ * @return bool
+ */
+ public function isCaching() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param boolean|array $options
+ * @return \Phalcon\Mvc\View
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return View
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Disables the auto-rendering process
+ *
+ * @return View
+ */
+ public function disable() {}
+
+ /**
+ * Enables the auto-rendering process
+ *
+ * @return View
+ */
+ public function enable() {}
+
+ /**
+ * Resets the view component to its factory default values
+ *
+ * @return View
+ */
+ public function reset() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+ /**
+ * Whether automatic rendering is enabled
+ *
+ * @return bool
+ */
+ public function isDisabled() {}
+
+ /**
+ * Magic method to retrieve if a variable is set in the view
+ *
+ * echo isset($this->view->products);
+ *
+ *
+ * @param string $key
+ * @return boolean
+ */
+ public function __isset($key) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/ViewBaseInterface.php b/ide/2.0.3/Phalcon/mvc/ViewBaseInterface.php
new file mode 100644
index 000000000..46a137337
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/ViewBaseInterface.php
@@ -0,0 +1,77 @@
+x or array[x].
+ */
+class Document implements \ArrayAccess
+{
+
+ /**
+ * Checks whether an offset exists in the document
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Returns the value of a field using the ArrayAccess interfase
+ *
+ * @param string $index
+ * @return mixed
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Change a value using the ArrayAccess interface
+ *
+ * @param string $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/collection/Exception.php b/ide/2.0.3/Phalcon/mvc/collection/Exception.php
new file mode 100644
index 000000000..736016ca9
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/collection/Exception.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $di->set('collectionManager', function(){
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized;
+
+
+ protected $_lastInitialized;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_connectionServices;
+
+
+ protected $_implicitObjectsIds;
+
+
+ protected $_behaviors;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService) {}
+
+ /**
+ * Sets whether a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds) {}
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Mongo
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ * @return bool
+ */
+ public function missingMethod(\Phalcon\Mvc\CollectionInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/collection/ManagerInterface.php b/ide/2.0.3/Phalcon/mvc/collection/ManagerInterface.php
new file mode 100644
index 000000000..da86d1ec6
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/collection/ManagerInterface.php
@@ -0,0 +1,108 @@
+
+ * $di = new \Phalcon\Di();
+ * $di->set('collectionManager', function(){
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * robot = new Robots(di);
+ *
+ */
+interface ManagerInterface
+{
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager);
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName);
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized();
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService);
+
+ /**
+ * Sets if a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds);
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param \Phalcon\Mvc\CollectionInterface $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Binds a behavior to a collection
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior);
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/collection/behavior/SoftDelete.php b/ide/2.0.3/Phalcon/mvc/collection/behavior/SoftDelete.php
new file mode 100644
index 000000000..527ee606b
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/collection/behavior/SoftDelete.php
@@ -0,0 +1,21 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $collection = new Collection();
+ * $collection->setHandler(new PostsController());
+ * $collection->get('/posts/edit/{id}', 'edit');
+ * $app->mount($collection);
+ *
+ */
+class Collection implements \Phalcon\Mvc\Micro\CollectionInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_lazy;
+
+
+ protected $_handler;
+
+
+ protected $_handlers;
+
+
+ /**
+ * Internal function to add a handler to the group
+ *
+ * @param string|array $method
+ * @param string $routePattern
+ * @param mixed $handler
+ * @param string $name
+ */
+ protected function _addMap($method, $routePattern, $handler, $name) {}
+
+ /**
+ * Sets a prefix for all routes added to the collection
+ *
+ * @param string $prefix
+ * @return Collection
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the collection prefix if any
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Returns the registered handlers
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+ /**
+ * Sets the main handler
+ *
+ * @param mixed $handler
+ * @param boolean $lazy
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function setHandler($handler, $lazy = false) {}
+
+ /**
+ * Sets if the main handler must be lazy loaded
+ *
+ * @param bool $lazy
+ * @return Collection
+ */
+ public function setLazy($lazy) {}
+
+ /**
+ * Returns if the main handler must be lazy loaded
+ *
+ * @return bool
+ */
+ public function isLazy() {}
+
+ /**
+ * Returns the main handler
+ *
+ * @return mixed
+ */
+ public function getHandler() {}
+
+ /**
+ * Maps a route to a handler
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function map($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is GET
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function get($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is POST
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function post($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PUT
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function put($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PATCH
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function patch($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is HEAD
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function head($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is DELETE
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function delete($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is OPTIONS
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param mixed $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function options($routePattern, $handler, $name = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/micro/CollectionInterface.php b/ide/2.0.3/Phalcon/mvc/micro/CollectionInterface.php
new file mode 100644
index 000000000..30c219445
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/micro/CollectionInterface.php
@@ -0,0 +1,145 @@
+
+ * $robots = Robots::query()
+ * ->where("type = :type:")
+ * ->andWhere("year < 2000")
+ * ->bind(array("type" => "mechanical"))
+ * ->limit(5, 10)
+ * ->orderBy("name")
+ * ->execute();
+ *
+ */
+class Criteria implements \Phalcon\Mvc\Model\CriteriaInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_model;
+
+
+ protected $_params;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return null|\Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set a model on which the query will be executed
+ *
+ * @param string $modelName
+ * @return Criteria
+ */
+ public function setModelName($modelName) {}
+
+ /**
+ * Returns an internal model name on which the criteria will be applied
+ *
+ * @return string
+ */
+ public function getModelName() {}
+
+ /**
+ * Sets the bound parameters in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindParams
+ * @return Criteria
+ */
+ public function bind($bindParams) {}
+
+ /**
+ * Sets the bind types in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindTypes
+ * @return Criteria
+ */
+ public function bindTypes($bindTypes) {}
+
+ /**
+ * Sets the columns to be queried
+ *
+ * $criteria->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function columns($columns) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->join('Robots');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'LEFT');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->innerJoin('Robots');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $criteria->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $criteria->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the conditions parameter in the criteria
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator (deprecated)
+ *
+ * @deprecated 1.0.0
+ * @see \Phalcon\Mvc\Model\Criteria::andWhere()
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function addWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an OR operator
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Adds the conditions parameter to the criteria
+ *
+ * @param string $conditions
+ * @return Criteria
+ */
+ public function conditions($conditions) {}
+
+ /**
+ * Adds the order-by parameter to the criteria (deprecated)
+ *
+ * @deprecated 1.2.1
+ * @see \Phalcon\Mvc\Model\Criteria::orderBy()
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function order($orderColumns) {}
+
+ /**
+ * Adds the order-by parameter to the criteria
+ *
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function orderBy($orderColumns) {}
+
+ /**
+ * Adds the limit parameter to the criteria
+ *
+ * @param int $limit
+ * @param int $offset
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function limit($limit, $offset = null) {}
+
+ /**
+ * Adds the "for_update" parameter to the criteria
+ *
+ * @param bool $forUpdate
+ * @return Criteria
+ */
+ public function forUpdate($forUpdate = true) {}
+
+ /**
+ * Adds the "shared_lock" parameter to the criteria
+ *
+ * @param bool $sharedLock
+ * @return Criteria
+ */
+ public function sharedLock($sharedLock = true) {}
+
+ /**
+ * Sets the cache options in the criteria
+ * This method replaces all previously set cache options
+ *
+ * @param array $cache
+ * @return Criteria
+ */
+ public function cache($cache) {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere() {}
+
+ /**
+ * Returns the columns to be queried
+ *
+ * @return string|array|null
+ */
+ public function getColumns() {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions() {}
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit() {}
+
+ /**
+ * Returns the order parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getOrder() {}
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return Criteria
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data) {}
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function execute() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/CriteriaInterface.php b/ide/2.0.3/Phalcon/mvc/model/CriteriaInterface.php
new file mode 100644
index 000000000..495a337b3
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/CriteriaInterface.php
@@ -0,0 +1,219 @@
+
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function betweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function inWhere($expr, $values);
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function notInWhere($expr, $values);
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere();
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions();
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit();
+
+ /**
+ * Returns the order parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getOrder();
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams();
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return CriteriaInterface
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data);
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return ResultsetInterface
+ */
+ public function execute();
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/Exception.php b/ide/2.0.3/Phalcon/mvc/model/Exception.php
new file mode 100644
index 000000000..1685da6d4
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/Exception.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\DI();
+ * $di->set('modelsManager', function() {
+ * return new \Phalcon\Mvc\Model\Manager();
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\ManagerInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_readConnectionServices;
+
+
+ protected $_writeConnectionServices;
+
+
+ protected $_aliases;
+
+ /**
+ * Has many relations
+ */
+ protected $_hasMany;
+
+ /**
+ * Has many relations by model
+ */
+ protected $_hasManySingle;
+
+ /**
+ * Has one relations
+ */
+ protected $_hasOne;
+
+ /**
+ * Has one relations by model
+ */
+ protected $_hasOneSingle;
+
+ /**
+ * Belongs to relations
+ */
+ protected $_belongsTo;
+
+ /**
+ * All the relationships by model
+ */
+ protected $_belongsToSingle;
+
+ /**
+ * Has many-Through relations
+ */
+ protected $_hasManyToMany;
+
+ /**
+ * Has many-Through relations by model
+ */
+ protected $_hasManyToManySingle;
+
+ /**
+ * Mark initialized models
+ */
+ protected $_initialized;
+
+
+ protected $_sources;
+
+
+ protected $_schemas;
+
+ /**
+ * Models' behaviors
+ */
+ protected $_behaviors;
+
+ /**
+ * Last model initialized
+ */
+ protected $_lastInitialized;
+
+ /**
+ * Last query created/executed
+ */
+ protected $_lastQuery;
+
+ /**
+ * Stores a list of reusable instances
+ */
+ protected $_reusable;
+
+
+ protected $_keepSnapshots;
+
+ /**
+ * Does the model use dynamic update, instead of updating all rows?
+ */
+ protected $_dynamicUpdate;
+
+
+ protected $_namespaceAliases;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a global events manager
+ *
+ * @param mixed $eventsManager
+ * @return Manager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return bool|\Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Initializes a model in the model manager
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function initialize(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get last initialized model
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Loads a model throwing an exception if it doesn't exist
+ *
+ * @param string $modelName
+ * @param bool $newInstance
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function load($modelName, $newInstance = false) {}
+
+ /**
+ * Sets the mapped source for a model
+ *
+ * @param mixed $model
+ * @param string $source
+ */
+ public function setModelSource(\Phalcon\Mvc\ModelInterface $model, $source) {}
+
+ /**
+ * Returns the mapped source for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSource(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets the mapped schema for a model
+ *
+ * @param mixed $model
+ * @param string $schema
+ */
+ public function setModelSchema(\Phalcon\Mvc\ModelInterface $model, $schema) {}
+
+ /**
+ * Returns the mapped schema for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSchema(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets both write and read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets write connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setWriteConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setReadConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Returns the connection to read data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to write data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to read or write data related to a model depending on the connection services.
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ protected function _getConnection(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Returns the connection service name used to read data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getReadConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to write data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getWriteConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to read or write data related to a model depending on the connection services
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return string
+ */
+ public function _getConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ */
+ public function missingMethod(\Phalcon\Mvc\ModelInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if a model must keep snapshots
+ *
+ * @param mixed $model
+ * @param bool $keepSnapshots
+ */
+ public function keepSnapshots(\Phalcon\Mvc\ModelInterface $model, $keepSnapshots) {}
+
+ /**
+ * Checks if a model is keeping snapshots for the queried records
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isKeepingSnapshots(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * @param mixed $model
+ * @param bool $dynamicUpdate
+ */
+ public function useDynamicUpdate(\Phalcon\Mvc\ModelInterface $model, $dynamicUpdate) {}
+
+ /**
+ * Checks if a model is using dynamic update instead of all-field update
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingDynamicUpdate(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasOne(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse many to one between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addBelongsTo(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasMany(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a relation n-m between two models
+ *
+ * @param string fields
+ * @param string intermediateModel
+ * @param string intermediateFields
+ * @param string intermediateReferencedFields
+ * @param string referencedModel
+ * @param string referencedFields
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param array $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasManyToMany(\Phalcon\Mvc\ModelInterface $model, $fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Checks whether a model has a belongsTo relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsBelongsTo($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasMany($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasOne relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasOne($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasManyToMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasManyToMany($modelName, $modelRelation) {}
+
+ /**
+ * Returns a relation by its alias
+ *
+ * @param string $modelName
+ * @param string $alias
+ * @return bool|\Phalcon\Mvc\Model\Relation
+ */
+ public function getRelationByAlias($modelName, $alias) {}
+
+ /**
+ * Helper method to query records based on a relation definition
+ *
+ * @param mixed $relation
+ * @param string $method
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return \Phalcon\Mvc\Model\Resultset\Simple|\Phalcon\Mvc\Model\Resultset\Simple|false
+ */
+ public function getRelationRecords(\Phalcon\Mvc\Model\RelationInterface $relation, $method, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Returns a reusable object from the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ */
+ public function getReusableRecords($modelName, $key) {}
+
+ /**
+ * Stores a reusable record in the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ * @param mixed $records
+ */
+ public function setReusableRecords($modelName, $key, $records) {}
+
+ /**
+ * Clears the internal reusable list
+ */
+ public function clearReusableObjects() {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getBelongsToRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets hasMany related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getHasManyRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getHasOneRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets all the belongsTo relations defined in a model
+ *
+ * $relations = $modelsManager->getBelongsTo(new Robots());
+ *
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getBelongsTo(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getHasOne(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasManyToMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasManyToMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasOneAndHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Query all the relationships defined on a model
+ *
+ * @param string $modelName
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelations($modelName) {}
+
+ /**
+ * Query the first relationship defined between two models
+ *
+ * @param string $first
+ * @param string $second
+ * @return bool|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelationsBetween($first, $second) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query without execute it
+ *
+ * @param string $phql
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function createQuery($phql) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query and execute it
+ *
+ * @param string $phql
+ * @param mixed $placeholders
+ * @param mixed $types
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function executeQuery($phql, $placeholders = null, $types = null) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query\Builder
+ *
+ * @param mixed $params
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function createBuilder($params = null) {}
+
+ /**
+ * Returns the lastest query created or executed in the models manager
+ *
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function getLastQuery() {}
+
+ /**
+ * Registers shorter aliases for namespaces in PHQL statements
+ *
+ * @param string $alias
+ * @param string $namespaceName
+ */
+ public function registerNamespaceAlias($alias, $namespaceName) {}
+
+ /**
+ * Returns a real namespace from its alias
+ *
+ * @param string $alias
+ * @return string
+ */
+ public function getNamespaceAlias($alias) {}
+
+ /**
+ * Returns all the registered namespace aliases
+ *
+ * @return array
+ */
+ public function getNamespaceAliases() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/ManagerInterface.php b/ide/2.0.3/Phalcon/mvc/model/ManagerInterface.php
new file mode 100644
index 000000000..3ef43fb12
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/ManagerInterface.php
@@ -0,0 +1,366 @@
+
+ * use Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if (this->name == 'Peter') {
+ * text = "A robot cannot be named Peter";
+ * field = "name";
+ * type = "InvalidValue";
+ * message = new Message(text, field, type);
+ * this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ */
+class Message implements \Phalcon\Mvc\Model\MessageInterface
+{
+
+ protected $_type;
+
+
+ protected $_message;
+
+
+ protected $_field;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Message constructor
+ *
+ * @param string $message
+ * @param string|array $field
+ * @param string $type
+ * @param \Phalcon\Mvc\ModelInterface $model
+ */
+ public function __construct($message, $field = null, $type = null, $model = null) {}
+
+ /**
+ * Sets message type
+ *
+ * @param string $type
+ * @return Message
+ */
+ public function setType($type) {}
+
+ /**
+ * Returns message type
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Sets verbose message
+ *
+ * @param string $message
+ * @return Message
+ */
+ public function setMessage($message) {}
+
+ /**
+ * Returns verbose message
+ *
+ * @return string
+ */
+ public function getMessage() {}
+
+ /**
+ * Sets field name related to message
+ *
+ * @param mixed $field
+ * @return Message
+ */
+ public function setField($field) {}
+
+ /**
+ * Returns field name related to message
+ */
+ public function getField() {}
+
+ /**
+ * Set the model who generates the message
+ *
+ * @param mixed $model
+ * @return Message
+ */
+ public function setModel(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the model that produced the message
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Magic __toString method returns verbose message
+ *
+ * @return string
+ */
+ public function __toString() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable exporting
+ *
+ * @param array $message
+ * @return Message
+ */
+ public static function __set_state($message) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/MessageInterface.php b/ide/2.0.3/Phalcon/mvc/model/MessageInterface.php
new file mode 100644
index 000000000..e192339b2
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/MessageInterface.php
@@ -0,0 +1,78 @@
+Because Phalcon\Mvc\Model requires meta-data like field names, data types, primary keys, etc.
+ * this component collect them and store for further querying by Phalcon\Mvc\Model.
+ * Phalcon\Mvc\Model\MetaData can also use adapters to store temporarily or permanently the meta-data.
+ * A standard Phalcon\Mvc\Model\MetaData can be used to query model attributes:
+ *
+ * $metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
+ * $attributes = $metaData->getAttributes(new Robots());
+ * print_r($attributes);
+ *
+ */
+abstract class MetaData implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const MODELS_ATTRIBUTES = 0;
+
+
+ const MODELS_PRIMARY_KEY = 1;
+
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+
+ const MODELS_NOT_NULL = 3;
+
+
+ const MODELS_DATA_TYPES = 4;
+
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+
+ const MODELS_DATE_AT = 6;
+
+
+ const MODELS_DATE_IN = 7;
+
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+
+ const MODELS_EMPTY_STRING_VALUES = 13;
+
+
+ const MODELS_COLUMN_MAP = 0;
+
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_strategy;
+
+
+ protected $_metaData;
+
+
+ protected $_columnMap;
+
+
+ /**
+ * Initialize the metadata for certain table
+ *
+ * @param mixed $model
+ * @param mixed $key
+ * @param mixed $table
+ * @param mixed $schema
+ */
+ protected final function _initialize(\Phalcon\Mvc\ModelInterface $model, $key, $table, $schema) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set the meta-data extraction strategy
+ *
+ * @param mixed $strategy
+ */
+ public function setStrategy(\Phalcon\Mvc\Model\MetaData\StrategyInterface $strategy) {}
+
+ /**
+ * Return the strategy to obtain the meta-data
+ *
+ * @return \Phalcon\Mvc\Model\MetaData\StrategyInterface
+ */
+ public function getStrategy() {}
+
+ /**
+ * Reads the complete meta-data for certain model
+ *
+ * print_r($metaData->readMetaData(new Robots());
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readMetaData(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads meta-data for certain model
+ *
+ * print_r($metaData->readMetaDataIndex(new Robots(), 0);
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Writes meta-data for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ * @param mixed $data
+ */
+ public final function writeMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index, $data) {}
+
+ /**
+ * Reads the ordered/reversed column map for certain model
+ *
+ * print_r($metaData->readColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads column-map information for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->readColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readColumnMapIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Returns table attributes names (fields)
+ *
+ * print_r($metaData->getAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are part of the primary key
+ *
+ * print_r($metaData->getPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are not part of the primary key
+ *
+ * print_r($metaData->getNonPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNonPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of not null attributes
+ *
+ * print_r($metaData->getNotNullAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNotNullAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their data types
+ *
+ * print_r($metaData->getDataTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes which types are numerical
+ *
+ * print_r($metaData->getDataTypesNumeric(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypesNumeric(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the name of identity field (if one is present)
+ *
+ * print_r($metaData->getIdentityField(new Robots()));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @return string
+ */
+ public function getIdentityField(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their bind data types
+ *
+ * print_r($metaData->getBindTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getBindTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the INSERT SQL generation
+ *
+ * print_r($metaData->getAutomaticCreateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the UPDATE SQL generation
+ *
+ * print_r($metaData->getAutomaticUpdateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Set the attributes that must be ignored from the INSERT SQL generation
+ *
+ * $metaData->setAutomaticCreateAttributes(new Robots(), array('created_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that must be ignored from the UPDATE SQL generation
+ *
+ * $metaData->setAutomaticUpdateAttributes(new Robots(), array('modified_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that allow empty string values
+ *
+ * $metaData->setEmptyStringAttributes(new Robots(), array('name' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Returns attributes allow empty strings
+ *
+ * print_r($metaData->getEmptyStringAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes (which have default values) and their default values
+ *
+ * print_r($metaData->getDefaultValues(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDefaultValues(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the column map if any
+ *
+ * print_r($metaData->getColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the reverse column map if any
+ *
+ * print_r($metaData->getReverseColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getReverseColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check if a model has certain attribute
+ *
+ * var_dump($metaData->hasAttribute(new Robots(), 'name'));
+ *
+ *
+ * @param mixed $model
+ * @param string $attribute
+ * @return bool
+ */
+ public function hasAttribute(\Phalcon\Mvc\ModelInterface $model, $attribute) {}
+
+ /**
+ * Checks if the internal meta-data container is empty
+ *
+ * var_dump($metaData->isEmpty());
+ *
+ *
+ * @return bool
+ */
+ public function isEmpty() {}
+
+ /**
+ * Resets internal meta-data in order to regenerate it
+ *
+ * $metaData->reset();
+ *
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/MetaDataInterface.php b/ide/2.0.3/Phalcon/mvc/model/MetaDataInterface.php
new file mode 100644
index 000000000..930c326a7
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/MetaDataInterface.php
@@ -0,0 +1,241 @@
+
+ * $phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
+ * WHERE b.name = :name: ORDER BY c.name";
+ * $result = manager->executeQuery($phql, array(
+ * "name": "Lamborghini"
+ * ));
+ * foreach ($result as $row) {
+ * echo "Name: ", $row->cars->name, "\n";
+ * echo "Price: ", $row->cars->price, "\n";
+ * echo "Taxes: ", $row->taxes, "\n";
+ * }
+ *
+ */
+class Query implements \Phalcon\Mvc\Model\QueryInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ const TYPE_SELECT = 309;
+
+
+ const TYPE_INSERT = 306;
+
+
+ const TYPE_UPDATE = 300;
+
+
+ const TYPE_DELETE = 303;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_manager;
+
+
+ protected $_metaData;
+
+
+ protected $_type;
+
+
+ protected $_phql;
+
+
+ protected $_ast;
+
+
+ protected $_intermediate;
+
+
+ protected $_models;
+
+
+ protected $_sqlAliases;
+
+
+ protected $_sqlAliasesModels;
+
+
+ protected $_sqlModelsAliases;
+
+
+ protected $_sqlAliasesModelsInstances;
+
+
+ protected $_sqlColumnAliases;
+
+
+ protected $_modelsInstances;
+
+
+ protected $_cache;
+
+
+ protected $_cacheOptions;
+
+
+ protected $_uniqueRow;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ static protected $_irPhqlCache;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query constructor
+ *
+ * @param string $phql
+ * @param \Phalcon\DiInterface $dependencyInjector
+ */
+ public function __construct($phql = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Tells to the query if only the first row in the resultset must be returned
+ *
+ * @param bool $uniqueRow
+ * @return Query
+ */
+ public function setUniqueRow($uniqueRow) {}
+
+ /**
+ * Check if the query is programmed to get only the first row in the resultset
+ *
+ * @return bool
+ */
+ public function getUniqueRow() {}
+
+ /**
+ * Replaces the model's name to its source name in a qualifed-name expression
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getQualified($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $argument
+ * @return array
+ */
+ protected final function _getCallArgument($argument) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getCaseExpression($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getFunctionCall($expr) {}
+
+ /**
+ * Resolves an expression from its intermediate code into a string
+ *
+ * @param array $expr
+ * @param boolean $quoting
+ * @return string
+ */
+ protected final function _getExpression($expr, $quoting = true) {}
+
+ /**
+ * Resolves a column from its intermediate representation into an array used to determine
+ * if the resultset produced is simple or complex
+ *
+ * @param array $column
+ * @return array
+ */
+ protected final function _getSelectColumn($column) {}
+
+ /**
+ * Resolves a table in a SELECT statement checking if the model exists
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $qualifiedName
+ * @return string
+ */
+ protected final function _getTable(\Phalcon\Mvc\Model\ManagerInterface $manager, $qualifiedName) {}
+
+ /**
+ * Resolves a JOIN clause checking if the associated models exist
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $join
+ * @return array
+ */
+ protected final function _getJoin(\Phalcon\Mvc\Model\ManagerInterface $manager, $join) {}
+
+ /**
+ * Resolves a JOIN type
+ *
+ * @param array $join
+ * @return string
+ */
+ protected final function _getJoinType($join) {}
+
+ /**
+ * Resolves joins involving has-one/belongs-to/has-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getSingleJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Resolves joins involving many-to-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getMultiJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Processes the JOINs in the query returning an internal representation for the database dialect
+ *
+ * @param array $select
+ * @return array
+ */
+ protected final function _getJoins($select) {}
+
+ /**
+ * Returns a processed order clause for a SELECT statement
+ *
+ * @param mixed $order
+ * @param array|string $$order
+ * @return array
+ */
+ protected final function _getOrderClause($order) {}
+
+ /**
+ * Returns a processed group clause for a SELECT statement
+ *
+ * @param mixed $group
+ * @param array $$group
+ * @return array
+ */
+ protected final function _getGroupClause($group) {}
+
+ /**
+ * Returns a processed limit clause for a SELECT statement
+ *
+ * @param mixed $limitClause
+ * @param array $$limit
+ * @return array
+ */
+ protected final function _getLimitClause($limitClause) {}
+
+ /**
+ * Analyzes a SELECT intermediate code and produces an array to be executed later
+ *
+ * @param mixed $ast
+ * @param mixed $merge
+ * @return array
+ */
+ protected final function _prepareSelect($ast = null, $merge = null) {}
+
+ /**
+ * Analyzes an INSERT intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareInsert() {}
+
+ /**
+ * Analyzes an UPDATE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareUpdate() {}
+
+ /**
+ * Analyzes a DELETE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareDelete() {}
+
+ /**
+ * Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another
+ * intermediate representation that could be executed by Phalcon\Mvc\Model\Query
+ *
+ * @return array
+ */
+ public function parse() {}
+
+ /**
+ * Returns the current cache backend instance
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Executes the SELECT intermediate representation producing a Phalcon\Mvc\Model\Resultset
+ *
+ * @param mixed $intermediate
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @param bool $simulate
+ * @return array|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _executeSelect($intermediate, $bindParams, $bindTypes, $simulate = false) {}
+
+ /**
+ * Executes the INSERT intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeInsert($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the UPDATE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeUpdate($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the DELETE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeDelete($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Query the records on which the UPDATE/DELETE operation well be done
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _getRelatedRecords(\Phalcon\Mvc\ModelInterface $model, $intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes a parsed PHQL statement
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return mixed
+ */
+ public function execute($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Executes the query returning the first result
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return Ṕhalcon\Mvc\ModelInterface
+ */
+ public function getSingleResult($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sets the type of PHQL statement to be executed
+ *
+ * @param int $type
+ * @return Query
+ */
+ public function setType($type) {}
+
+ /**
+ * Gets the type of PHQL statement executed
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindParams
+ * @return Query
+ */
+ public function setBindParams($bindParams) {}
+
+ /**
+ * Returns default bind params
+ *
+ * @return array
+ */
+ public function getBindParams() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindTypes
+ * @return Query
+ */
+ public function setBindTypes($bindTypes) {}
+
+ /**
+ * Returns default bind types
+ *
+ * @return array
+ */
+ public function getBindTypes() {}
+
+ /**
+ * Allows to set the IR to be executed
+ *
+ * @param array $intermediate
+ * @return Query
+ */
+ public function setIntermediate($intermediate) {}
+
+ /**
+ * Returns the intermediate representation of the PHQL statement
+ *
+ * @return array
+ */
+ public function getIntermediate() {}
+
+ /**
+ * Sets the cache parameters of the query
+ *
+ * @param mixed $cacheOptions
+ * @return Query
+ */
+ public function cache($cacheOptions) {}
+
+ /**
+ * Returns the current cache options
+ *
+ * @param array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
+ *
+ * @return array
+ */
+ public function getSql() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/QueryInterface.php b/ide/2.0.3/Phalcon/mvc/model/QueryInterface.php
new file mode 100644
index 000000000..058d68f18
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/QueryInterface.php
@@ -0,0 +1,59 @@
+
+ * //Using a standard foreach
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ * //Using a while
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * $robots->rewind();
+ * while ($robots->valid()) {
+ * $robot = $robots->current();
+ * echo $robot->name, "\n";
+ * $robots->next();
+ * }
+ *
+ */
+abstract class Resultset implements \Phalcon\Mvc\Model\ResultsetInterface, \Iterator, \SeekableIterator, \Countable, \ArrayAccess, \Serializable
+{
+
+ const TYPE_RESULT_FULL = 0;
+
+
+ const TYPE_RESULT_PARTIAL = 1;
+
+
+ const HYDRATE_RECORDS = 0;
+
+
+ const HYDRATE_OBJECTS = 2;
+
+
+ const HYDRATE_ARRAYS = 1;
+
+ /**
+ * Phalcon\Db\ResultInterface or false for empty resultset
+ */
+ protected $_result = false;
+
+
+ protected $_cache;
+
+
+ protected $_isFresh = true;
+
+
+ protected $_pointer = 0;
+
+
+ protected $_count;
+
+
+ protected $_activeRow = null;
+
+
+ protected $_rows = null;
+
+
+ protected $_row = null;
+
+
+ protected $_errorMessages;
+
+
+ protected $_hydrateMode = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Resultset constructor
+ *
+ * @param \Phalcon\Db\ResultInterface|false $result
+ * @param \Phalcon\Cache\BackendInterface $cache
+ * @param array $columnTypes
+ */
+ public function __construct($result, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Moves cursor to next row in the resultset
+ */
+ public function next() {}
+
+ /**
+ * Check whether internal resource has rows to fetch
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Gets pointer number of active row in the resultset
+ *
+ * @return int|null
+ */
+ public function key() {}
+
+ /**
+ * Rewinds resultset to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Changes internal pointer to a specific position in the resultset
+ * Set new position if required and set this->_row
+ *
+ * @param int $position
+ */
+ public final function seek($position) {}
+
+ /**
+ * Counts how many rows are in the resultset
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Checks whether offset exists in the resultset
+ *
+ * @param int $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets row in a specific position of the resultset
+ *
+ * @param int $index
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Returns the internal type of data retrieval that the resultset is using
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Get first row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getFirst() {}
+
+ /**
+ * Get last row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getLast() {}
+
+ /**
+ * Set if the resultset is fresh or an old one cached
+ *
+ * @param bool $isFresh
+ * @return Resultset
+ */
+ public function setIsFresh($isFresh) {}
+
+ /**
+ * Tell if the resultset if fresh or an old one cached
+ *
+ * @return bool
+ */
+ public function isFresh() {}
+
+ /**
+ * Sets the hydration mode in the resultset
+ *
+ * @param int $hydrateMode
+ * @return Resultset
+ */
+ public function setHydrateMode($hydrateMode) {}
+
+ /**
+ * Returns the current hydration mode
+ *
+ * @return int
+ */
+ public function getHydrateMode() {}
+
+ /**
+ * Returns the associated cache for the resultset
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Returns the error messages produced by a batch operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Updates every record in the resultset
+ *
+ * @param array $data
+ * @param Closure $conditionCallback
+ * @return boolean
+ */
+ public function update($data, \Closure $conditionCallback = null) {}
+
+ /**
+ * Deletes every record in the resultset
+ *
+ * @param mixed $conditionCallback
+ * @return bool
+ */
+ public function delete(\Closure $conditionCallback = null) {}
+
+ /**
+ * Filters a resultset returning only those the developer requires
+ *
+ * $filtered = $robots->filter(function($robot){
+ * if ($robot->id < 3) {
+ * return $robot;
+ * }
+ * });
+ *
+ *
+ * @param callback $filter
+ * @return \Phalcon\Mvc\Model[]
+ */
+ public function filter($filter) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/ResultsetInterface.php b/ide/2.0.3/Phalcon/mvc/model/ResultsetInterface.php
new file mode 100644
index 000000000..58903e36e
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/ResultsetInterface.php
@@ -0,0 +1,62 @@
+x or array[x].
+ */
+class Row implements \ArrayAccess, \Phalcon\Mvc\Model\ResultInterface
+{
+
+ /**
+ * Set the current object's state
+ *
+ * @param int $dirtyState
+ * @return bool
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Checks whether offset exists in the row
+ *
+ * @param mixed $index
+ * @param string|int $$index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets a record in a specific position of the row
+ *
+ * @param string|int $index
+ * @return string|Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/Transaction.php b/ide/2.0.3/Phalcon/mvc/model/Transaction.php
new file mode 100644
index 000000000..cfc88900d
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/Transaction.php
@@ -0,0 +1,146 @@
+
+ * try {
+ * $manager = new \Phalcon\Mvc\Model\Transaction\Manager();
+ * $transaction = $manager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch(Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Transaction implements \Phalcon\Mvc\Model\TransactionInterface
+{
+
+ protected $_connection;
+
+
+ protected $_activeTransaction = false;
+
+
+ protected $_isNewTransaction = true;
+
+
+ protected $_rollbackOnAbort = false;
+
+
+ protected $_manager;
+
+
+ protected $_messages;
+
+
+ protected $_rollbackRecord;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param boolean $autoBegin
+ * @param string $service
+ * @param \Phalcon\DiInterface $$ependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector, $autoBegin = false, $service = null) {}
+
+ /**
+ * Sets transaction manager related to the transaction
+ *
+ * @param mixed $manager
+ */
+ public function setTransactionManager(\Phalcon\Mvc\Model\Transaction\ManagerInterface $manager) {}
+
+ /**
+ * Starts the transaction
+ *
+ * @return bool
+ */
+ public function begin() {}
+
+ /**
+ * Commits the transaction
+ *
+ * @return bool
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks the transaction
+ *
+ * @param string $rollbackMessage
+ * @param \Phalcon\Mvc\ModelInterface $rollbackRecord
+ * @return boolean
+ */
+ public function rollback($rollbackMessage = null, $rollbackRecord = null) {}
+
+ /**
+ * Returns the connection related to transaction
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection() {}
+
+ /**
+ * Sets if is a reused transaction or new once
+ *
+ * @param bool $isNew
+ */
+ public function setIsNewTransaction($isNew) {}
+
+ /**
+ * Sets flag to rollback on abort the HTTP connection
+ *
+ * @param bool $rollbackOnAbort
+ */
+ public function setRollbackOnAbort($rollbackOnAbort) {}
+
+ /**
+ * Checks whether transaction is managed by a transaction manager
+ *
+ * @return bool
+ */
+ public function isManaged() {}
+
+ /**
+ * Returns validations messages from last save try
+ *
+ * @return array
+ */
+ public function getMessages() {}
+
+ /**
+ * Checks whether internal connection is under an active transaction
+ *
+ * @return bool
+ */
+ public function isValid() {}
+
+ /**
+ * Sets object which generates rollback action
+ *
+ * @param mixed $record
+ */
+ public function setRollbackedRecord(\Phalcon\Mvc\ModelInterface $record) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/TransactionInterface.php b/ide/2.0.3/Phalcon/mvc/model/TransactionInterface.php
new file mode 100644
index 000000000..88a500734
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/TransactionInterface.php
@@ -0,0 +1,91 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Apc(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Apc extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from APC
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/metadata/Files.php b/ide/2.0.3/Phalcon/mvc/model/metadata/Files.php
new file mode 100644
index 000000000..86b59be2c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/metadata/Files.php
@@ -0,0 +1,43 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Files(array(
+ * 'metaDataDir' => 'app/cache/metadata/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_metaDataDir = "./";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from files
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to files
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/metadata/Memory.php b/ide/2.0.3/Phalcon/mvc/model/metadata/Memory.php
new file mode 100644
index 000000000..c389c473f
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/metadata/Memory.php
@@ -0,0 +1,35 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Session(array(
+ * 'prefix' => 'my-app-id'
+ * ));
+ *
+ */
+class Session extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Session constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from $_SESSION
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to $_SESSION
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/metadata/StrategyInterface.php b/ide/2.0.3/Phalcon/mvc/model/metadata/StrategyInterface.php
new file mode 100644
index 000000000..b7874be24
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/metadata/StrategyInterface.php
@@ -0,0 +1,28 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Xcache(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Xcache extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Xcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from XCache
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to XCache
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/metadata/strategy/Annotations.php b/ide/2.0.3/Phalcon/mvc/model/metadata/strategy/Annotations.php
new file mode 100644
index 000000000..f1b7b11fa
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/metadata/strategy/Annotations.php
@@ -0,0 +1,27 @@
+
+ * $params = array(
+ * 'models' => array('Users'),
+ * 'columns' => array('id', 'name', 'status'),
+ * 'conditions' => array(
+ * array(
+ * "created > :min: AND created < :max:",
+ * array("min" => '2013-01-01', 'max' => '2014-01-01'),
+ * array("min" => PDO::PARAM_STR, 'max' => PDO::PARAM_STR),
+ * ),
+ * ),
+ * // or 'conditions' => "created > '2013-01-01' AND created < '2014-01-01'",
+ * 'group' => array('id', 'name'),
+ * 'having' => "name = 'Kamil'",
+ * 'order' => array('name', 'id'),
+ * 'limit' => 20,
+ * 'offset' => 20,
+ * // or 'limit' => array(20, 20),
+ * );
+ * $queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);
+ *
+ */
+class Builder implements \Phalcon\Mvc\Model\Query\BuilderInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_columns;
+
+
+ protected $_models;
+
+
+ protected $_joins;
+
+
+ protected $_with;
+
+
+ protected $_conditions;
+
+
+ protected $_group;
+
+
+ protected $_having;
+
+
+ protected $_order;
+
+
+ protected $_limit;
+
+
+ protected $_offset;
+
+
+ protected $_forUpdate;
+
+
+ protected $_sharedLock;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_distinct;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Builder constructor
+ *
+ * @param mixed $params
+ * @param mixed $dependencyInjector
+ */
+ public function __construct($params = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ * @return Builder
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param bool|null $distinct
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function distinct($distinct) {}
+
+ /**
+ * Returns SELECT DISTINCT / SELECT ALL flag
+ *
+ * @return bool
+ */
+ public function getDistinct() {}
+
+ /**
+ * Sets the columns to be queried
+ *
+ * $builder->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function columns($columns) {}
+
+ /**
+ * Return the columns to be queried
+ *
+ * @return string|array
+ */
+ public function getColumns() {}
+
+ /**
+ * Sets the models who makes part of the query
+ *
+ * $builder->from('Robots');
+ * $builder->from(array('Robots', 'RobotsParts'));
+ *
+ *
+ * @param string|array $models
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function from($models) {}
+
+ /**
+ * Add a model to take part of the query
+ *
+ * $builder->addFrom('Robots', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function addFrom($model, $alias = null) {}
+
+ /**
+ * Return the models who makes part of the query
+ *
+ * @return string|array
+ */
+ public function getFrom() {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->join('Robots');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'INNER');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->innerJoin('Robots');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $builder->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $builder->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the query conditions
+ *
+ * $builder->where(100);
+ * $builder->where('name = "Peter"');
+ * $builder->where('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param mixed $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a AND operator
+ *
+ * $builder->andWhere('name = "Peter"');
+ * $builder->andWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a OR operator
+ *
+ * $builder->orWhere('name = "Peter"');
+ * $builder->orWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $builder->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $builder->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $builder->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $builder->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Return the conditions for the query
+ *
+ * @return string|array
+ */
+ public function getWhere() {}
+
+ /**
+ * Sets a ORDER BY condition clause
+ *
+ * $builder->orderBy('Robots.name');
+ * $builder->orderBy(array('1', 'Robots.name'));
+ *
+ *
+ * @param string|array $orderBy
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orderBy($orderBy) {}
+
+ /**
+ * Returns the set ORDER BY clause
+ *
+ * @return string|array
+ */
+ public function getOrderBy() {}
+
+ /**
+ * Sets a HAVING condition clause. You need to escape PHQL reserved words using [ and ] delimiters
+ *
+ * $builder->having('SUM(Robots.price) > 0');
+ *
+ *
+ * @param string $having
+ * @return Builder
+ */
+ public function having($having) {}
+
+ /**
+ * Return the current having clause
+ *
+ * @return string|array
+ */
+ public function getHaving() {}
+
+ /**
+ * Sets a LIMIT clause, optionally a offset clause
+ *
+ * $builder->limit(100);
+ * $builder->limit(100, 20);
+ *
+ *
+ * @param int $limit
+ * @param int $offset
+ * @return Builder
+ */
+ public function limit($limit = null, $offset = null) {}
+
+ /**
+ * Returns the current LIMIT clause
+ *
+ * @return string|array
+ */
+ public function getLimit() {}
+
+ /**
+ * Sets an OFFSET clause
+ *
+ * $builder->offset(30);
+ *
+ *
+ * @param int $offset
+ * @return Builder
+ */
+ public function offset($offset) {}
+
+ /**
+ * Returns the current OFFSET clause
+ *
+ * @return string|array
+ */
+ public function getOffset() {}
+
+ /**
+ * Sets a GROUP BY clause
+ *
+ * $builder->groupBy(array('Robots.name'));
+ *
+ *
+ * @param string|array $group
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function groupBy($group) {}
+
+ /**
+ * Returns the GROUP BY clause
+ *
+ * @return string
+ */
+ public function getGroupBy() {}
+
+ /**
+ * Returns a PHQL statement built based on the builder parameters
+ *
+ * @return string
+ */
+ public final function getPhql() {}
+
+ /**
+ * Returns the query built
+ *
+ * @return \Phalcon\Mvc\Model\Query
+ */
+ public function getQuery() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/query/BuilderInterface.php b/ide/2.0.3/Phalcon/mvc/model/query/BuilderInterface.php
new file mode 100644
index 000000000..9e8b04895
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/query/BuilderInterface.php
@@ -0,0 +1,249 @@
+
+ * $intermediate = Phalcon\Mvc\Model\Query\Lang::parsePHQL("SELECT r.* FROM Robots r LIMIT 10");
+ *
+ */
+abstract class Lang
+{
+
+ /**
+ * Parses a PHQL statement returning an intermediate representation (IR)
+ *
+ * @param string $phql
+ * @return string
+ */
+ public static function parsePHQL($phql) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/query/Status.php b/ide/2.0.3/Phalcon/mvc/model/query/Status.php
new file mode 100644
index 000000000..44bd6423d
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/query/Status.php
@@ -0,0 +1,63 @@
+
+ * $phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";
+ * $status = $app->modelsManager->executeQuery($phql, array(
+ * 'id' => 100,
+ * 'name' => 'Astroy Boy',
+ * 'type' => 'mechanical',
+ * 'year' => 1959
+ * ));
+ * \//Check if the update was successful
+ * if ($status->success() == true) {
+ * echo 'OK';
+ * }
+ *
+ */
+class Status implements \Phalcon\Mvc\Model\Query\StatusInterface
+{
+
+ protected $_success;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Status
+ *
+ * @param bool $success
+ * @param mixed $model
+ */
+ public function __construct($success, \Phalcon\Mvc\ModelInterface $model = null) {}
+
+ /**
+ * Returns the model that executed the action
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Returns the messages produced because of a failed operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Allows to check if the executed operation was successful
+ *
+ * @return bool
+ */
+ public function success() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/query/StatusInterface.php b/ide/2.0.3/Phalcon/mvc/model/query/StatusInterface.php
new file mode 100644
index 000000000..9b1b58318
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/query/StatusInterface.php
@@ -0,0 +1,41 @@
+
+ * try {
+ * use Phalcon\Mvc\Model\Transaction\Manager as TransactionManager;
+ * $transactionManager = new TransactionManager();
+ * $transaction = $transactionManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if($robot->save()==false){
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if($robotPart->save()==false){
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch (Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\Transaction\ManagerInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized = false;
+
+
+ protected $_rollbackPendent = true;
+
+
+ protected $_number = 0;
+
+
+ protected $_service = "db";
+
+
+ protected $_transactions;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction\Manager constructor
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the database service used to run the isolated transactions
+ *
+ * @param string $service
+ * @return Manager
+ */
+ public function setDbService($service) {}
+
+ /**
+ * Returns the database service used to isolate the transaction
+ *
+ * @return string
+ */
+ public function getDbService() {}
+
+ /**
+ * Set if the transaction manager must register a shutdown function to clean up pendent transactions
+ *
+ * @param bool $rollbackPendent
+ * @return Manager
+ */
+ public function setRollbackPendent($rollbackPendent) {}
+
+ /**
+ * Check if the transaction manager is registering a shutdown function to clean up pendent transactions
+ *
+ * @return bool
+ */
+ public function getRollbackPendent() {}
+
+ /**
+ * Checks whether the manager has an active transaction
+ *
+ * @return bool
+ */
+ public function has() {}
+
+ /**
+ * Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
+ * This method registers a shutdown function to rollback active connections
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function get($autoBegin = true) {}
+
+ /**
+ * Create/Returns a new transaction or an existing one
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function getOrCreateTransaction($autoBegin = true) {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ */
+ public function rollbackPendent() {}
+
+ /**
+ * Commmits active transactions within the manager
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ * Collect will remove the transaction from the manager
+ *
+ * @param boolean $collect
+ */
+ public function rollback($collect = true) {}
+
+ /**
+ * Notifies the manager about a rollbacked transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyRollback(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Notifies the manager about a commited transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyCommit(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Removes transactions from the TransactionManager
+ *
+ * @param mixed $transaction
+ */
+ protected function _collectTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Remove all the transactions from the manager
+ */
+ public function collectTransactions() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/transaction/ManagerInterface.php b/ide/2.0.3/Phalcon/mvc/model/transaction/ManagerInterface.php
new file mode 100644
index 000000000..5fc97d481
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/transaction/ManagerInterface.php
@@ -0,0 +1,71 @@
+
+ * use Phalcon\Mvc\Model\Validator\Email as EmailValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new EmailValidator(array(
+ * 'field' => 'electronic_mail'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Email extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Email() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/Exclusionin.php b/ide/2.0.3/Phalcon/mvc/model/validator/Exclusionin.php
new file mode 100644
index 000000000..d8f806162
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/Exclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionInValidator(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Exclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Exclusionin() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/Inclusionin.php b/ide/2.0.3/Phalcon/mvc/model/validator/Inclusionin.php
new file mode 100644
index 000000000..645982781
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/Inclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\InclusionIn as InclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new InclusionInValidator(array(
+ * "field" => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Inclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Inclusionin() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/Numericality.php b/ide/2.0.3/Phalcon/mvc/model/validator/Numericality.php
new file mode 100644
index 000000000..5a7bad6e4
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/Numericality.php
@@ -0,0 +1,38 @@
+
+ * use Phalcon\Mvc\Model\Validator\Numericality as NumericalityValidator;
+ * class Products extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new NumericalityValidator(array(
+ * "field" => 'price'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Numericality extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Numericality() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/PresenceOf.php b/ide/2.0.3/Phalcon/mvc/model/validator/PresenceOf.php
new file mode 100644
index 000000000..f99e9cdd6
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/PresenceOf.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\PresenceOf;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new PresenceOf(array(
+ * "field" => 'name',
+ * "message" => 'The name is required'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class PresenceOf extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_PresenceOf() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/Regex.php b/ide/2.0.3/Phalcon/mvc/model/validator/Regex.php
new file mode 100644
index 000000000..14ec2d327
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/Regex.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\Regex as RegexValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new RegexValidator(array(
+ * "field" => 'created_at',
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])/'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Regex extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Regex() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/StringLength.php b/ide/2.0.3/Phalcon/mvc/model/validator/StringLength.php
new file mode 100644
index 000000000..1b3c585cc
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/StringLength.php
@@ -0,0 +1,42 @@
+
+ * use Phalcon\Mvc\Model\Validator\StringLength as StringLengthValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new StringLengthValidator(array(
+ * "field" => 'name_last',
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class StringLength extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_StringLength() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/Uniqueness.php b/ide/2.0.3/Phalcon/mvc/model/validator/Uniqueness.php
new file mode 100644
index 000000000..2f8a98a20
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/Uniqueness.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\Uniqueness as Uniqueness;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new Uniqueness(array(
+ * "field" => 'email'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Uniqueness extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Uniqueness() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/model/validator/Url.php b/ide/2.0.3/Phalcon/mvc/model/validator/Url.php
new file mode 100644
index 000000000..4e35bf2d4
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/model/validator/Url.php
@@ -0,0 +1,38 @@
+
+ * use Phalcon\Mvc\Model\Validator\Url as UrlValidator;
+ * class Posts extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new UrlValidator(array(
+ * 'field' => 'source_url'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Url extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Url() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/router/Annotations.php b/ide/2.0.3/Phalcon/mvc/router/Annotations.php
new file mode 100644
index 000000000..20343fb9d
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/router/Annotations.php
@@ -0,0 +1,105 @@
+
+ * $di['router'] = function() {
+ * //Use the annotations router
+ * $router = new Annotations(false);
+ * //This will do the same as above but only if the handled uri starts with /robots
+ * $router->addResource('Robots', '/robots');
+ * return $router;
+ * };
+ *
+ */
+class Annotations extends \Phalcon\Mvc\Router
+{
+
+ protected $_handlers;
+
+
+ protected $_processed = false;
+
+
+ protected $_controllerSuffix = "Controller";
+
+
+ protected $_actionSuffix = "Action";
+
+
+ protected $_routePrefix;
+
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ *
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addResource($handler, $prefix = null) {}
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ * The class is located in a module
+ *
+ * @param string $module
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addModuleResource($module, $handler, $prefix = null) {}
+
+ /**
+ * Produce the routing parameters from the rewrite information
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Checks for annotations in the controller docblock
+ *
+ * @param string $handler
+ * @param mixed $annotation
+ */
+ public function processControllerAnnotation($handler, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Checks for annotations in the public methods of the controller
+ *
+ * @param string $module
+ * @param string $namespaceName
+ * @param string $controller
+ * @param string $action
+ * @param \Phalcon\Annotations\Annotation $annotation
+ */
+ public function processActionAnnotation($module, $namespaceName, $controller, $action, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Changes the controller class suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Changes the action method suffix
+ *
+ * @param string $actionSuffix
+ */
+ public function setActionSuffix($actionSuffix) {}
+
+ /**
+ * Return the registered resources
+ *
+ * @return array
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/router/Exception.php b/ide/2.0.3/Phalcon/mvc/router/Exception.php
new file mode 100644
index 000000000..e8a40f672
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/router/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+class Group implements \Phalcon\Mvc\Router\GroupInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_hostname;
+
+
+ protected $_paths;
+
+
+ protected $_routes;
+
+
+ protected $_beforeMatch;
+
+
+ /**
+ * Phalcon\Mvc\Router\Group constructor
+ *
+ * @param mixed $paths
+ */
+ public function __construct($paths = null) {}
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param mixed $paths
+ * @return GroupInterface
+ */
+ public function setPaths($paths) {}
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addGet($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPost($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPut($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPatch($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addDelete($pattern, $paths = null) {}
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addOptions($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addHead($pattern, $paths = null) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Adds a route applying the common attributes
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ protected function _addRoute($pattern, $paths = null, $httpMethods = null) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/router/GroupInterface.php b/ide/2.0.3/Phalcon/mvc/router/GroupInterface.php
new file mode 100644
index 000000000..bd9481889
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/router/GroupInterface.php
@@ -0,0 +1,186 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+interface GroupInterface
+{
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname);
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname();
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix);
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix();
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch);
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch();
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param array $paths
+ * @return \Phalcon\Mvc\Router\Group
+ */
+ public function setPaths($paths);
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths();
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes();
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null);
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null);
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear();
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/router/Route.php b/ide/2.0.3/Phalcon/mvc/router/Route.php
new file mode 100644
index 000000000..5cb392f08
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/router/Route.php
@@ -0,0 +1,243 @@
+
+ * $route->via('GET');
+ * $route->via(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function via($httpMethods) {}
+
+ /**
+ * Extracts parameters from a string
+ *
+ * @param string $pattern
+ * @return array|bool
+ */
+ public function extractNamedParams($pattern) {}
+
+ /**
+ * Reconfigure the route adding a new pattern and a set of paths
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ */
+ public function reConfigure($pattern, $paths = null) {}
+
+ /**
+ * Returns routePaths
+ *
+ * @param mixed $paths
+ * @return array
+ */
+ public static function getRoutePaths($paths = null) {}
+
+ /**
+ * Returns the route's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets the route's name
+ *
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $callback
+ * @return Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Sets a set of HTTP methods that constraint the matching of the route (alias of via)
+ *
+ * $route->setHttpMethods('GET');
+ * $route->setHttpMethods(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function setHttpMethods($httpMethods) {}
+
+ /**
+ * Returns the HTTP methods that constraint matching the route
+ *
+ * @return array|string
+ */
+ public function getHttpMethods() {}
+
+ /**
+ * Sets a hostname restriction to the route
+ *
+ * $route->setHostname('localhost');
+ *
+ *
+ * @param string $hostname
+ * @return Route
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction if any
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Sets the group associated with the route
+ *
+ * @param mixed $group
+ * @return Route
+ */
+ public function setGroup(GroupInterface $group) {}
+
+ /**
+ * Returns the group associated with the route
+ *
+ * @return null|GroupInterface
+ */
+ public function getGroup() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param mixed $converter
+ * @return Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/router/RouteInterface.php b/ide/2.0.3/Phalcon/mvc/router/RouteInterface.php
new file mode 100644
index 000000000..e49f3af1d
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/router/RouteInterface.php
@@ -0,0 +1,113 @@
+
+ * $view = new \Phalcon\Mvc\View\Simple();
+ * echo $view->render('templates/my-view', array('content' => $html));
+ * //or with filename with extension
+ * echo $view->render('templates/my-view.volt', array('content' => $html));
+ *
+ */
+class Simple extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewBaseInterface
+{
+
+ protected $_options;
+
+
+ protected $_viewsDir;
+
+
+ protected $_partialsDir;
+
+
+ protected $_viewParams;
+
+
+ protected $_engines = false;
+
+
+ protected $_registeredEngines;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_content;
+
+
+ protected $_cache = false;
+
+
+ protected $_cacheOptions;
+
+
+
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View\Simple constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Tries to render the view with every engine registered in the component
+ *
+ * @param string $path
+ * @param array $params
+ */
+ protected final function _internalRender($path, $params) {}
+
+ /**
+ * Renders a view
+ *
+ * @param string $path
+ * @param array $params
+ * @return string
+ */
+ public function render($path, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Sets the cache options
+ *
+ * @param array $options
+ * @return \Phalcon\Mvc\View\Simple
+ */
+ public function setCacheOptions($options) {}
+
+ /**
+ * Returns the cache options
+ *
+ * @return array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param mixed $options
+ * @return Simple
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param bool $merge
+ * @return Simple
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return Simple
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/mvc/view/engine/Php.php b/ide/2.0.3/Phalcon/mvc/view/engine/Php.php
new file mode 100644
index 000000000..d554be8de
--- /dev/null
+++ b/ide/2.0.3/Phalcon/mvc/view/engine/Php.php
@@ -0,0 +1,21 @@
+
+ * $compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();
+ * $compiler->compile('views/partials/header.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ */
+class Compiler implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_view;
+
+
+ protected $_options;
+
+
+ protected $_arrayHelpers;
+
+
+ protected $_level = 0;
+
+
+ protected $_foreachLevel = 0;
+
+
+ protected $_blockLevel = 0;
+
+
+ protected $_exprLevel = 0;
+
+
+ protected $_extended = false;
+
+
+ protected $_autoescape = false;
+
+
+ protected $_extendedBlocks;
+
+
+ protected $_currentBlock;
+
+
+ protected $_blocks;
+
+
+ protected $_forElsePointers;
+
+
+ protected $_loopPointers;
+
+
+ protected $_extensions;
+
+
+ protected $_functions;
+
+
+ protected $_filters;
+
+
+ protected $_macros;
+
+
+ protected $_prefix;
+
+
+ protected $_currentPath;
+
+
+ protected $_compiledTemplatePath;
+
+
+ /**
+ * Phalcon\Mvc\View\Engine\Volt\Compiler
+ *
+ * @param mixed $view
+ */
+ public function __construct(\Phalcon\Mvc\ViewBaseInterface $view = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the compiler options
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Sets a single compiler option
+ *
+ * @param string $option
+ * @param mixed $value
+ */
+ public function setOption($option, $value) {}
+
+ /**
+ * Returns a compiler's option
+ *
+ * @param string $option
+ * @return string
+ */
+ public function getOption($option) {}
+
+ /**
+ * Returns the compiler options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+ * Fires an event to registered extensions
+ *
+ * @param string $name
+ * @param array $arguments
+ * @return mixed
+ */
+ public final function fireExtensionEvent($name, $arguments = null) {}
+
+ /**
+ * Registers a Volt's extension
+ *
+ * @param object $extension
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+ */
+ public function addExtension($extension) {}
+
+ /**
+ * Returns the list of extensions registered in Volt
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register a new function in the compiler
+ *
+ * @param string $name
+ * @param Closure|string $definition
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+ */
+ public function addFunction($name, $definition) {}
+
+ /**
+ * Register the user registered functions
+ *
+ * @return array
+ */
+ public function getFunctions() {}
+
+ /**
+ * Register a new filter in the compiler
+ *
+ * @param string $name
+ * @param Closure|string $definition
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+ */
+ public function addFilter($name, $definition) {}
+
+ /**
+ * Register the user registered filters
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+ /**
+ * Set a unique prefix to be used as prefix for compiled variables
+ *
+ * @param string $prefix
+ * @return Compiler
+ */
+ public function setUniquePrefix($prefix) {}
+
+ /**
+ * Return a unique prefix to be used as prefix for compiled variables and contexts
+ *
+ * @return string
+ */
+ public function getUniquePrefix() {}
+
+ /**
+ * Resolves attribute reading
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function attributeReader($expr) {}
+
+ /**
+ * Resolves function intermediate code into PHP function calls
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function functionCall($expr) {}
+
+ /**
+ * Resolves filter intermediate code into a valid PHP expression
+ *
+ * @param array $test
+ * @param string $left
+ * @return string
+ */
+ public function resolveTest($test, $left) {}
+
+ /**
+ * Resolves filter intermediate code into PHP function calls
+ *
+ * @param array $filter
+ * @param string $left
+ * @return string
+ */
+ final protected function resolveFilter($filter, $left) {}
+
+ /**
+ * Resolves an expression node in an AST volt tree
+ *
+ * @param array $expr
+ * @return string
+ */
+ final public function expression($expr) {}
+
+ /**
+ * Compiles a block of statements
+ *
+ * @param array $statements
+ * @return string|array
+ */
+ final protected function _statementListOrExtends($statements) {}
+
+ /**
+ * Compiles a "foreach" intermediate code representation into plain PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileForeach($statement, $extendsMode = false) {}
+
+ /**
+ * Generates a 'forelse' PHP code
+ *
+ * @return string
+ */
+ public function compileForElse() {}
+
+ /**
+ * Compiles a 'if' statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileIf($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "elseif" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileElseIf($statement) {}
+
+ /**
+ * Compiles a "cache" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileCache($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "set" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileSet($statement) {}
+
+ /**
+ * Compiles a "do" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileDo($statement) {}
+
+ /**
+ * Compiles a "return" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileReturn($statement) {}
+
+ /**
+ * Compiles a "autoescape" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileAutoEscape($statement, $extendsMode) {}
+
+ /**
+ * Compiles a '{{' '}}' statement returning PHP code
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileEcho($statement) {}
+
+ /**
+ * Compiles a 'include' statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileInclude($statement) {}
+
+ /**
+ * Compiles macros
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileMacro($statement, $extendsMode) {}
+
+ /**
+ * Compiles calls to macros
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileCall($statement, $extendsMode) {}
+
+ /**
+ * Traverses a statement list compiling each of its nodes
+ *
+ * @param array $statements
+ * @param bool $extendsMode
+ * @return string
+ */
+ final protected function _statementList($statements, $extendsMode = false) {}
+
+ /**
+ * Compiles a Volt source code returning a PHP plain version
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ protected function _compileSource($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a string
+ *
+ * echo $compiler->compileString('{{ "hello world" }}');
+ *
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileString($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file forcing the destination path
+ *
+ * $compiler->compile('views/layouts/main.volt', 'views/layouts/main.volt.php');
+ *
+ *
+ * @param string $path
+ * @param string $compiledPath
+ * @param boolean $extendsMode
+ * @return string|array
+ */
+ public function compileFile($path, $compiledPath, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file applying the compiler options
+ * This method does not return the compiled path if the template was not compiled
+ *
+ * $compiler->compile('views/layouts/main.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ *
+ * @param string $templatePath
+ * @param boolean $extendsMode
+ * @return string|array
+ */
+ public function compile($templatePath, $extendsMode = false) {}
+
+ /**
+ * Returns the path that is currently being compiled
+ *
+ * @return string
+ */
+ public function getTemplatePath() {}
+
+ /**
+ * Returns the path to the last compiled template
+ *
+ * @return string
+ */
+ public function getCompiledTemplatePath() {}
+
+ /**
+ * Parses a Volt template returning its intermediate representation
+ *
+ * print_r($compiler->parse('{{ 3 + 2 }}'));
+ *
+ *
+ * @param string $viewCode
+ * @return array
+ */
+ public function parse($viewCode) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/paginator/Adapter.php b/ide/2.0.3/Phalcon/paginator/Adapter.php
new file mode 100644
index 000000000..8a4dcf3fe
--- /dev/null
+++ b/ide/2.0.3/Phalcon/paginator/Adapter.php
@@ -0,0 +1,44 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => Robots::find(),
+ * "limit" => 25,
+ * "page" => $currentPage
+ * )
+ * );
+ * $paginate = $paginator->getPaginate();
+ *
+ */
+class Model extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\Model constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdclass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/paginator/adapter/NativeArray.php b/ide/2.0.3/Phalcon/paginator/adapter/NativeArray.php
new file mode 100644
index 000000000..d9dc50611
--- /dev/null
+++ b/ide/2.0.3/Phalcon/paginator/adapter/NativeArray.php
@@ -0,0 +1,46 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => array(
+ * array('id' => 1, 'name' => 'Artichoke'),
+ * array('id' => 2, 'name' => 'Carrots'),
+ * array('id' => 3, 'name' => 'Beet'),
+ * array('id' => 4, 'name' => 'Lettuce'),
+ * array('id' => 5, 'name' => '')
+ * ),
+ * "limit" => 2,
+ * "page" => $currentPage
+ * )
+ * );
+ *
+ */
+class NativeArray extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of the paginator
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\NativeArray constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/paginator/adapter/QueryBuilder.php b/ide/2.0.3/Phalcon/paginator/adapter/QueryBuilder.php
new file mode 100644
index 000000000..3a6af396f
--- /dev/null
+++ b/ide/2.0.3/Phalcon/paginator/adapter/QueryBuilder.php
@@ -0,0 +1,69 @@
+
+ * $builder = $this->modelsManager->createBuilder()
+ * ->columns('id, name')
+ * ->from('Robots')
+ * ->orderBy('name');
+ * $paginator = new Phalcon\Paginator\Adapter\QueryBuilder(array(
+ * "builder" => $builder,
+ * "limit"=> 20,
+ * "page" => 1
+ * ));
+ *
+ */
+class QueryBuilder extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config;
+
+ /**
+ * Paginator's data
+ */
+ protected $_builder;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\QueryBuilder
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Get the current page number
+ *
+ * @return int
+ */
+ public function getCurrentPage() {}
+
+ /**
+ * Set query builder object
+ *
+ * @param mixed $builder
+ * @return QueryBuilder
+ */
+ public function setQueryBuilder(\Phalcon\Mvc\Model\Query\Builder $builder) {}
+
+ /**
+ * Get query builder object
+ *
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function getQueryBuilder() {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/queue/Beanstalk.php b/ide/2.0.3/Phalcon/queue/Beanstalk.php
new file mode 100644
index 000000000..f5377b197
--- /dev/null
+++ b/ide/2.0.3/Phalcon/queue/Beanstalk.php
@@ -0,0 +1,135 @@
+
+ * session->setOptions(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ *
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get internal options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+ * Gets a session variable from an application context
+ *
+ * @param string $index
+ * @param mixed $defaultValue
+ * @param boolean $remove
+ * @return mixed
+ */
+ public function get($index, $defaultValue = null, $remove = false) {}
+
+ /**
+ * Sets a session variable in an application context
+ *
+ * session->set('auth', 'yes');
+ *
+ *
+ * @param string $index
+ * @param string $value
+ */
+ public function set($index, $value) {}
+
+ /**
+ * Check whether a session variable is set in an application context
+ *
+ * var_dump($session->has('auth'));
+ *
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function has($index) {}
+
+ /**
+ * Removes a session variable from an application context
+ *
+ * $session->remove('auth');
+ *
+ *
+ * @param string $index
+ */
+ public function remove($index) {}
+
+ /**
+ * Returns active session id
+ *
+ * echo $session->getId();
+ *
+ *
+ * @return string
+ */
+ public function getId() {}
+
+ /**
+ * Set the current session id
+ *
+ * $session->setId($id);
+ *
+ *
+ * @param string $id
+ */
+ public function setId($id) {}
+
+ /**
+ * Check whether the session has been started
+ *
+ * var_dump($session->isStarted());
+ *
+ *
+ * @return bool
+ */
+ public function isStarted() {}
+
+ /**
+ * Destroys the active session
+ *
+ * var_dump($session->destroy());
+ *
+ *
+ * @return bool
+ */
+ public function destroy() {}
+
+ /**
+ * Returns the status of the current session. For PHP 5.3 this function will always return SESSION_NONE
+ *
+ * var_dump($session->status());
+ * // PHP 5.4 and above will give meaningful messages, 5.3 gets SESSION_NONE always
+ * if ($session->status() !== $session::SESSION_ACTIVE) {
+ * $session->start();
+ * }
+ *
+ *
+ * @return int
+ */
+ public function status() {}
+
+ /**
+ * Alias: Gets a session variable from an application context
+ *
+ * @param string $index
+ * @return mixed
+ */
+ public function __get($index) {}
+
+ /**
+ * Alias: Sets a session variable in an application context
+ *
+ * @param string $index
+ * @param string $value
+ */
+ public function __set($index, $value) {}
+
+ /**
+ * Alias: Check whether a session variable is set in an application context
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function __isset($index) {}
+
+ /**
+ * Alias: Removes a session variable from an application context
+ *
+ * @param string $index
+ */
+ public function __unset($index) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/session/AdapterInterface.php b/ide/2.0.3/Phalcon/session/AdapterInterface.php
new file mode 100644
index 000000000..814efc411
--- /dev/null
+++ b/ide/2.0.3/Phalcon/session/AdapterInterface.php
@@ -0,0 +1,84 @@
+
+ * $user = new \Phalcon\Session\Bag('user');
+ * $user->name = "Kimbra Johnson";
+ * $user->age = 22;
+ *
+ */
+class Bag implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Session\BagInterface, \IteratorAggregate, \ArrayAccess, \Countable
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_name = null;
+
+
+ protected $_data;
+
+
+ protected $_initialized = false;
+
+
+ protected $_session;
+
+
+ /**
+ * Phalcon\Session\Bag constructor
+ *
+ * @param string $name
+ */
+ public function __construct($name) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed
+ */
+ public function initialize() {}
+
+ /**
+ * Destroyes the session bag
+ *
+ * $user->destroy();
+ *
+ */
+ public function destroy() {}
+
+ /**
+ * Sets a value in the session bag
+ *
+ * $user->set('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function set($property, $value) {}
+
+ /**
+ * Magic setter to assign values to the session bag
+ *
+ * $user->name = "Kimbra";
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Obtains a value from the session bag optionally setting a default value
+ *
+ * echo $user->get('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $defaultValue
+ * @return mixed
+ */
+ public function get($property, $defaultValue = null) {}
+
+ /**
+ * Magic getter to obtain values from the session bag
+ *
+ * echo $user->name;
+ *
+ *
+ * @param string $property
+ * @return mixed
+ */
+ public function __get($property) {}
+
+ /**
+ * Check whether a property is defined in the internal bag
+ *
+ * var_dump($user->has('name'));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function has($property) {}
+
+ /**
+ * Magic isset to check whether a property is defined in the bag
+ *
+ * var_dump(isset($user['name']));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Removes a property from the internal bag
+ *
+ * $user->remove('name');
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function remove($property) {}
+
+ /**
+ * Magic unset to remove items using the array syntax
+ *
+ * unset($user['name']);
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __unset($property) {}
+
+ /**
+ * Return length of bag
+ *
+ * echo $user->count();
+ *
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Returns the bag iterator
+ *
+ * @return \ArrayIterator
+ */
+ public final function getIterator() {}
+
+ /**
+ * @param string $property
+ * @param mixed $value
+ */
+ public final function offsetSet($property, $value) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetExists($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetUnset($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetGet($property) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/session/BagInterface.php b/ide/2.0.3/Phalcon/session/BagInterface.php
new file mode 100644
index 000000000..c36cc1973
--- /dev/null
+++ b/ide/2.0.3/Phalcon/session/BagInterface.php
@@ -0,0 +1,71 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Files extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+}
diff --git a/ide/2.0.3/Phalcon/session/adapter/Libmemcached.php b/ide/2.0.3/Phalcon/session/adapter/Libmemcached.php
new file mode 100644
index 000000000..54ec0e0ad
--- /dev/null
+++ b/ide/2.0.3/Phalcon/session/adapter/Libmemcached.php
@@ -0,0 +1,88 @@
+
+ * $session = new Phalcon\Session\Adapter\Libmemcached(array(
+ * 'servers' => array(
+ * array('host' => 'localhost', 'port' => 11211, 'weight' => 1),
+ * ),
+ * 'client' => array(
+ * Memcached::OPT_HASH => Memcached::HASH_MD5,
+ * Memcached::OPT_PREFIX_KEY => 'prefix.',
+ * ),
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Libmemcached extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_libmemcached = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getLibmemcached() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Libmemcached constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options) {}
+
+ /**
+ * @return bool
+ */
+ public function open() {}
+
+ /**
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @return bool
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/session/adapter/Memcache.php b/ide/2.0.3/Phalcon/session/adapter/Memcache.php
new file mode 100644
index 000000000..83b9edf17
--- /dev/null
+++ b/ide/2.0.3/Phalcon/session/adapter/Memcache.php
@@ -0,0 +1,79 @@
+
+ * $session = new \Phalcon\Session\Adapter\Memcache(array(
+ * 'uniqueId' => 'my-private-app'
+ * 'host' => '127.0.0.1',
+ * 'port' => 11211,
+ * 'persistent' => TRUE,
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Memcache extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_memcache = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getMemcache() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Memcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = array()) {}
+
+
+ public function open() {}
+
+
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.3/Phalcon/tag/Exception.php b/ide/2.0.3/Phalcon/tag/Exception.php
new file mode 100644
index 000000000..8d2604755
--- /dev/null
+++ b/ide/2.0.3/Phalcon/tag/Exception.php
@@ -0,0 +1,12 @@
+
+ * print_r($messages[0]);
+ *
+ *
+ * @param int $index
+ * @return \Phalcon\Validation\Message
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $messages[0] = new \Phalcon\Validation\Message('This is a message');
+ *
+ *
+ * @param int $index
+ * @param \Phalcon\Validation\Message $message
+ */
+ public function offsetSet($index, $message) {}
+
+ /**
+ * Checks if an index exists
+ *
+ * var_dump(isset($message['database']));
+ *
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Removes a message from the list
+ *
+ * unset($message['database']);
+ *
+ *
+ * @param string $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Appends a message to the group
+ *
+ * $messages->appendMessage(new \Phalcon\Validation\Message('This is a message'));
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Validation\MessageInterface $message) {}
+
+ /**
+ * Appends an array of messages to the group
+ *
+ * $messages->appendMessages($messagesArray);
+ *
+ *
+ * @param \Phalcon\Validation\MessageInterface[] $messages
+ */
+ public function appendMessages($messages) {}
+
+ /**
+ * Filters the message group by field name
+ *
+ * @param string $fieldName
+ * @return array
+ */
+ public function filter($fieldName) {}
+
+ /**
+ * Returns the number of messages in the list
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current message in the iterator
+ *
+ * @return \Phalcon\Validation\Message
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current message in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable when exporting
+ *
+ * @param array $group
+ * @return \Phalcon\Validation\Message\Group
+ */
+ public static function __set_state($group) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Alnum.php b/ide/2.0.3/Phalcon/validation/validator/Alnum.php
new file mode 100644
index 000000000..96250226c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Alnum.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alnum as AlnumValidator;
+ * $validator->add('username', new AlnumValidator(array(
+ * 'message' => ':field must contain only alphanumeric characters'
+ * )));
+ *
+ */
+class Alnum extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Alpha.php b/ide/2.0.3/Phalcon/validation/validator/Alpha.php
new file mode 100644
index 000000000..3860505fd
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Alpha.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alpha as AlphaValidator;
+ * $validator->add('username', new AlphaValidator(array(
+ * 'message' => ':field must contain only letters'
+ * )));
+ *
+ */
+class Alpha extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Between.php b/ide/2.0.3/Phalcon/validation/validator/Between.php
new file mode 100644
index 000000000..9a765abd7
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Between.php
@@ -0,0 +1,30 @@
+
+ * use Phalcon\Validation\Validator\Between;
+ * validator->add('name', new Between(array(
+ * 'minimum' => 0,
+ * 'maximum' => 100,
+ * 'message' => 'The price must be between 0 and 100'
+ * )));
+ *
+ */
+class Between extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Confirmation.php b/ide/2.0.3/Phalcon/validation/validator/Confirmation.php
new file mode 100644
index 000000000..fb105f12e
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Confirmation.php
@@ -0,0 +1,37 @@
+
+ * use Phalcon\Validation\Validator\Confirmation;
+ * $validator->add('password', new Confirmation(array(
+ * 'message' => 'Password doesn\'t match confirmation',
+ * 'with' => 'confirmPassword'
+ * )));
+ *
+ */
+class Confirmation extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+ /**
+ * Compare strings
+ *
+ * @param string $a
+ * @param string $b
+ * @return bool
+ */
+ protected function compare($a, $b) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Digit.php b/ide/2.0.3/Phalcon/validation/validator/Digit.php
new file mode 100644
index 000000000..dae4e4dbe
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Digit.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Digit as DigitValidator;
+ * $validator->add('height', new DigitValidator(array(
+ * 'message' => ':field must be numeric'
+ * )));
+ *
+ */
+class Digit extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Email.php b/ide/2.0.3/Phalcon/validation/validator/Email.php
new file mode 100644
index 000000000..8951305fc
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Email.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Email as EmailValidator;
+ * $validator->add('email', new EmailValidator(array(
+ * 'message' => 'The e-mail is not valid'
+ * )));
+ *
+ */
+class Email extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/ExclusionIn.php b/ide/2.0.3/Phalcon/validation/validator/ExclusionIn.php
new file mode 100644
index 000000000..d6bd01efa
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/ExclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\ExclusionIn;
+ * $validator->add('status', new ExclusionIn(array(
+ * 'message' => 'The status must not be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class ExclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/File.php b/ide/2.0.3/Phalcon/validation/validator/File.php
new file mode 100644
index 000000000..96121dc85
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/File.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\File as FileValidator;
+ * $validator->add('file', new FileValidator(array(
+ * 'maxSize' => '2M',
+ * 'messageSize' => ':field exceeds the max filesize (:max)',
+ * 'allowedTypes' => array('image/jpeg', 'image/png'),
+ * 'messageType' => 'Allowed file types are :types',
+ * 'maxResolution' => '800x600',
+ * 'messageMaxResolution' => 'Max resolution of :field is :max'
+ * )));
+ *
+ */
+class File extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Identical.php b/ide/2.0.3/Phalcon/validation/validator/Identical.php
new file mode 100644
index 000000000..d5ee453cc
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Identical.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Identical;
+ * $validator->add('terms', new Identical(array(
+ * 'accepted' => 'yes',
+ * 'message' => 'Terms and conditions must be accepted'
+ * )));
+ *
+ */
+class Identical extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/InclusionIn.php b/ide/2.0.3/Phalcon/validation/validator/InclusionIn.php
new file mode 100644
index 000000000..4bee62023
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/InclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\InclusionIn;
+ * $validator->add('status', new InclusionIn(array(
+ * 'message' => 'The status must be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class InclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Numericality.php b/ide/2.0.3/Phalcon/validation/validator/Numericality.php
new file mode 100644
index 000000000..5b68ec926
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Numericality.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Numericality;
+ * $validator->add('price', new Numericality(array(
+ * 'message' => ':field is not numeric'
+ * )));
+ *
+ */
+class Numericality extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/PresenceOf.php b/ide/2.0.3/Phalcon/validation/validator/PresenceOf.php
new file mode 100644
index 000000000..30ba729ed
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/PresenceOf.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\PresenceOf;
+ * $validator->add('name', new PresenceOf(array(
+ * 'message' => 'The name is required'
+ * )));
+ *
+ */
+class PresenceOf extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Regex.php b/ide/2.0.3/Phalcon/validation/validator/Regex.php
new file mode 100644
index 000000000..8b73552b6
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Regex.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Regex as RegexValidator;
+ * $validator->add('created_at', new RegexValidator(array(
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/',
+ * 'message' => 'The creation date is invalid'
+ * )));
+ *
+ */
+class Regex extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/StringLength.php b/ide/2.0.3/Phalcon/validation/validator/StringLength.php
new file mode 100644
index 000000000..2bafa9675
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/StringLength.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\StringLength as StringLength;
+ * $validation->add('name_last', new StringLength(array(
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ *
+ */
+class StringLength extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Uniqueness.php b/ide/2.0.3/Phalcon/validation/validator/Uniqueness.php
new file mode 100644
index 000000000..79ef4083c
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Uniqueness.php
@@ -0,0 +1,35 @@
+
+ * use Phalcon\Validation\Validator\Uniqueness as UniquenessValidator;
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'message' => ':field must be unique'
+ * )));
+ *
+ * Different attribute from the field
+ *
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'attribute' => 'nick'
+ * )));
+ *
+ */
+class Uniqueness extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.3/Phalcon/validation/validator/Url.php b/ide/2.0.3/Phalcon/validation/validator/Url.php
new file mode 100644
index 000000000..76ab65b91
--- /dev/null
+++ b/ide/2.0.3/Phalcon/validation/validator/Url.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Url as UrlValidator;
+ * $validator->add('url', new UrlValidator(array(
+ * 'message' => ':field must be a url'
+ * )));
+ *
+ */
+class Url extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Acl.php b/ide/2.0.4/Phalcon/Acl.php
new file mode 100644
index 000000000..54a8d3549
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Acl.php
@@ -0,0 +1,45 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * //Default action is deny access
+ * $acl->setDefaultAction(\Phalcon\Acl::DENY);
+ * //Create some roles
+ * $roleAdmins = new \Phalcon\Acl\Role('Administrators', 'Super-User role');
+ * $roleGuests = new \Phalcon\Acl\Role('Guests');
+ * //Add "Guests" role to acl
+ * $acl->addRole($roleGuests);
+ * //Add "Designers" role to acl
+ * $acl->addRole('Designers');
+ * //Define the "Customers" resource
+ * $customersResource = new \Phalcon\Acl\Resource('Customers', 'Customers management');
+ * //Add "customers" resource with a couple of operations
+ * $acl->addResource($customersResource, 'search');
+ * $acl->addResource($customersResource, array('create', 'update'));
+ * //Set access level for roles into resources
+ * $acl->allow('Guests', 'Customers', 'search');
+ * $acl->allow('Guests', 'Customers', 'create');
+ * $acl->deny('Guests', 'Customers', 'update');
+ * //Check whether role has access to the operations
+ * $acl->isAllowed('Guests', 'Customers', 'edit'); //Returns 0
+ * $acl->isAllowed('Guests', 'Customers', 'search'); //Returns 1
+ * $acl->isAllowed('Guests', 'Customers', 'create'); //Returns 1
+ *
+ */
+abstract class Acl
+{
+
+ const ALLOW = 1;
+
+
+ const DENY = 0;
+
+
+}
diff --git a/ide/2.0.4/Phalcon/Config.php b/ide/2.0.4/Phalcon/Config.php
new file mode 100644
index 000000000..b3112b0da
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Config.php
@@ -0,0 +1,145 @@
+
+ * $config = new \Phalcon\Config(array(
+ * "database" => array(
+ * "adapter" => "Mysql",
+ * "host" => "localhost",
+ * "username" => "scott",
+ * "password" => "cheetah",
+ * "dbname" => "test_db"
+ * ),
+ * "phalcon" => array(
+ * "controllersDir" => "../app/controllers/",
+ * "modelsDir" => "../app/models/",
+ * "viewsDir" => "../app/views/"
+ * )
+ * ));
+ *
+ */
+class Config implements \ArrayAccess, \Countable
+{
+
+ /**
+ * Phalcon\Config constructor
+ *
+ * @param array $arrayConfig
+ */
+ public function __construct($arrayConfig = null) {}
+
+ /**
+ * Allows to check whether an attribute is defined using the array-syntax
+ *
+ * var_dump(isset($config['database']));
+ *
+ *
+ * @param mixed $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets an attribute from the configuration, if the attribute isn't defined returns null
+ * If the value is exactly null or is not defined the default value will be used instead
+ *
+ * echo $config->get('controllersDir', '../app/controllers/');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $defaultValue
+ */
+ public function get($index, $defaultValue = null) {}
+
+ /**
+ * Gets an attribute using the array-syntax
+ *
+ * print_r($config['database']);
+ *
+ *
+ * @param mixed $index
+ * @return string
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $config['database'] = array('type' => 'Sqlite');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Unsets an attribute using the array-syntax
+ *
+ * unset($config['database']);
+ *
+ *
+ * @param mixed $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Merges a configuration into the current one
+ *
+ * $appConfig = new \Phalcon\Config(array('database' => array('host' => 'localhost')));
+ * $globalConfig->merge($config2);
+ *
+ *
+ * @param mixed $config
+ * @return Config
+ */
+ public function merge(Config $config) {}
+
+ /**
+ * Converts recursively the object to an array
+ *
+ * print_r($config->toArray());
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Returns the count of properties set in the config
+ *
+ * print count($config);
+ *
+ * or
+ *
+ * print $config->count();
+ *
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Restores the state of a Phalcon\Config object
+ *
+ * @param array $data
+ * @return Config
+ */
+ public static function __set_state($data) {}
+
+ /**
+ * Helper method for merge configs (forwarding nested config instance)
+ *
+ * @param Config $config
+ * @param Config $instance = null
+ * @return Config config
+ */
+ protected final function _merge(Config $config, $instance = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Crypt.php b/ide/2.0.4/Phalcon/Crypt.php
new file mode 100644
index 000000000..7ff497474
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Crypt.php
@@ -0,0 +1,194 @@
+
+ * $crypt = new \Phalcon\Crypt();
+ * $key = 'le password';
+ * $text = 'This is a secret text';
+ * $encrypted = $crypt->encrypt($text, $key);
+ * echo $crypt->decrypt($encrypted, $key);
+ *
+ */
+class Crypt implements \Phalcon\CryptInterface
+{
+
+ const PADDING_DEFAULT = 0;
+
+
+ const PADDING_ANSI_X_923 = 1;
+
+
+ const PADDING_PKCS7 = 2;
+
+
+ const PADDING_ISO_10126 = 3;
+
+
+ const PADDING_ISO_IEC_7816_4 = 4;
+
+
+ const PADDING_ZERO = 5;
+
+
+ const PADDING_SPACE = 6;
+
+
+ protected $_key;
+
+
+ protected $_padding = 0;
+
+
+ protected $_mode = "cbc";
+
+
+ protected $_cipher = "rijndael-256";
+
+
+ /**
+ * @brief Phalcon\CryptInterface Phalcon\Crypt::setPadding(int $scheme)
+ * @param int $scheme Padding scheme
+ * @return \Phalcon\CryptInterface
+ */
+ public function setPadding($scheme) {}
+
+ /**
+ * Sets the cipher algorithm
+ *
+ * @param string $cipher
+ * @return Crypt
+ */
+ public function setCipher($cipher) {}
+
+ /**
+ * Returns the current cipher
+ *
+ * @return string
+ */
+ public function getCipher() {}
+
+ /**
+ * Sets the encrypt/decrypt mode
+ *
+ * @param string $mode
+ * @return Crypt
+ */
+ public function setMode($mode) {}
+
+ /**
+ * Returns the current encryption mode
+ *
+ * @return string
+ */
+ public function getMode() {}
+
+ /**
+ * Sets the encryption key
+ *
+ * @param string $key
+ * @return Crypt
+ */
+ public function setKey($key) {}
+
+ /**
+ * Returns the encryption key
+ *
+ * @return string
+ */
+ public function getKey() {}
+
+ /**
+ * Adds padding @a padding_type to @a text
+ *
+ * @see http://www.di-mgt.com.au/cryptopad.html
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ * @param return_value $Result, possibly padded
+ * @param text $Message to be padded
+ * @param mode $Encryption mode; padding is applied only in CBC or ECB mode
+ * @param block_size $Cipher block size
+ * @param padding_type $Padding scheme
+ */
+ protected function _cryptPadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Removes padding @a padding_type from @a text
+ * If the function detects that the text was not padded, it will return it unmodified
+ *
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ * @param return_value $Result, possibly unpadded
+ * @param text $Message to be unpadded
+ * @param mode $Encryption mode; unpadding is applied only in CBC or ECB mode
+ * @param block_size $Cipher block size
+ * @param padding_type $Padding scheme
+ */
+ protected function _cryptUnpadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Encrypts a text
+ *
+ * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
+ *
+ *
+ * @param string $text
+ * @param string $key
+ * @return string
+ */
+ public function encrypt($text, $key = null) {}
+
+ /**
+ * Decrypts an encrypted text
+ *
+ * echo $crypt->decrypt($encrypted, "decrypt password");
+ *
+ *
+ * @param string $text
+ * @param mixed $key
+ * @return string
+ */
+ public function decrypt($text, $key = null) {}
+
+ /**
+ * Encrypts a text returning the result as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function encryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Decrypt a text that is coded as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function decryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Returns a list of available cyphers
+ *
+ * @return array
+ */
+ public function getAvailableCiphers() {}
+
+ /**
+ * Returns a list of available modes
+ *
+ * @return array
+ */
+ public function getAvailableModes() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/CryptInterface.php b/ide/2.0.4/Phalcon/CryptInterface.php
new file mode 100644
index 000000000..529103de4
--- /dev/null
+++ b/ide/2.0.4/Phalcon/CryptInterface.php
@@ -0,0 +1,107 @@
+
+ * try {
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306',
+ * ));
+ * $result = $connection->query("SELECTFROM robots LIMIT 5");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetch()) {
+ * print_r($robot);
+ * }
+ * } catch (Phalcon\Db\Exception $e) {
+ * echo $e->getMessage(), PHP_EOL;
+ * }
+ *
+ */
+abstract class Db
+{
+
+ const FETCH_LAZY = 1;
+
+
+ const FETCH_ASSOC = 2;
+
+
+ const FETCH_NAMED = 11;
+
+
+ const FETCH_NUM = 3;
+
+
+ const FETCH_BOTH = 4;
+
+
+ const FETCH_OBJ = 5;
+
+
+ const FETCH_BOUND = 6;
+
+
+ const FETCH_COLUMN = 7;
+
+
+ const FETCH_CLASS = 8;
+
+
+ const FETCH_INTO = 9;
+
+
+ const FETCH_FUNC = 10;
+
+
+ const FETCH_GROUP = 65536;
+
+
+ const FETCH_UNIQUE = 196608;
+
+
+ const FETCH_KEY_PAIR = 12;
+
+
+ const FETCH_CLASSTYPE = 262144;
+
+
+ const FETCH_SERIALIZE = 524288;
+
+
+ const FETCH_PROPS_LATE = 1048576;
+
+
+ /**
+ * Enables/disables options in the Database component
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Debug.php b/ide/2.0.4/Phalcon/Debug.php
new file mode 100644
index 000000000..4724a69a8
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Debug.php
@@ -0,0 +1,196 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+
+ protected $_theme = "default";
+
+
+ protected $_hideDocumentRoot = false;
+
+
+ protected $_showBackTrace = true;
+
+
+ protected $_showFiles = true;
+
+
+ protected $_showFileFragment = false;
+
+
+ protected $_data;
+
+
+ static protected $_isActive;
+
+
+ /**
+ * Change the base URI for static resources
+ *
+ * @param string $uri
+ * @return Debug
+ */
+ public function setUri($uri) {}
+
+ /**
+ * Sets if files the exception"s backtrace must be showed
+ *
+ * @param bool $showBackTrace
+ * @return Debug
+ */
+ public function setShowBackTrace($showBackTrace) {}
+
+ /**
+ * Set if files part of the backtrace must be shown in the output
+ *
+ * @param bool $showFiles
+ * @return Debug
+ */
+ public function setShowFiles($showFiles) {}
+
+ /**
+ * Sets if files must be completely opened and showed in the output
+ * or just the fragment related to the exception
+ *
+ * @param bool $showFileFragment
+ * @return Debug
+ */
+ public function setShowFileFragment($showFileFragment) {}
+
+ /**
+ * Listen for uncaught exceptions and unsilent notices or warnings
+ *
+ * @param bool $exceptions
+ * @param bool $lowSeverity
+ * @return Debug
+ */
+ public function listen($exceptions = true, $lowSeverity = false) {}
+
+ /**
+ * Listen for uncaught exceptions
+ *
+ * @return Debug
+ */
+ public function listenExceptions() {}
+
+ /**
+ * Listen for unsilent notices or warnings
+ *
+ * @return Debug
+ */
+ public function listenLowSeverity() {}
+
+ /**
+ * Halts the request showing a backtrace
+ */
+ public function halt() {}
+
+ /**
+ * Adds a variable to the debug output
+ *
+ * @param mixed $varz
+ * @param string $key
+ * @return Debug
+ */
+ public function debugVar($varz, $key = null) {}
+
+ /**
+ * Clears are variables added previously
+ *
+ * @return Debug
+ */
+ public function clearVars() {}
+
+ /**
+ * Escapes a string with htmlentities
+ *
+ * @param mixed $value
+ * @return string
+ */
+ protected function _escapeString($value) {}
+
+ /**
+ * Produces a recursive representation of an array
+ *
+ * @param array $argument
+ * @param mixed $n
+ * @return string|null
+ */
+ protected function _getArrayDump($argument, $n = 0) {}
+
+ /**
+ * Produces an string representation of a variable
+ *
+ * @param mixed $variable
+ * @return string
+ */
+ protected function _getVarDump($variable) {}
+
+ /**
+ * Returns the major framework's version
+ *
+ * @return string
+ */
+ public function getMajorVersion() {}
+
+ /**
+ * Generates a link to the current version documentation
+ *
+ * @return string
+ */
+ public function getVersion() {}
+
+ /**
+ * Returns the css sources
+ *
+ * @return string
+ */
+ public function getCssSources() {}
+
+ /**
+ * Returns the javascript sources
+ *
+ * @return string
+ */
+ public function getJsSources() {}
+
+ /**
+ * Shows a backtrace item
+ *
+ * @param int $n
+ * @param array $trace
+ */
+ protected final function showTraceItem($n, $trace) {}
+
+ /**
+ * Throws an exception when a notice or warning is raised
+ *
+ * @param mixed $severity
+ * @param mixed $message
+ * @param mixed $file
+ * @param mixed $line
+ */
+ public function onUncaughtLowSeverity($severity, $message, $file, $line) {}
+
+ /**
+ * Handles uncaught exceptions
+ *
+ * @param mixed $exception
+ * @return bool
+ */
+ public function onUncaughtException(\Exception $exception) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Di.php b/ide/2.0.4/Phalcon/Di.php
new file mode 100644
index 000000000..d94f2d2fe
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Di.php
@@ -0,0 +1,245 @@
+
+ * $di = new \Phalcon\Di();
+ * //Using a string definition
+ * $di->set("request", "Phalcon\Http\Request", true);
+ * //Using an anonymous function
+ * $di->set("request", function(){
+ * return new \Phalcon\Http\Request();
+ * }, true);
+ * $request = $di->getRequest();
+ *
+ */
+class Di implements \Phalcon\DiInterface
+{
+ /**
+ * List of registered services
+ */
+ protected $_services;
+
+ /**
+ * List of shared instances
+ */
+ protected $_sharedInstances;
+
+ /**
+ * To know if the latest resolved instance was shared or not
+ */
+ protected $_freshInstance = false;
+
+ /**
+ * Events Manager
+ *
+ * @var \Phalcon\Events\ManagerInterface
+ */
+ protected $_eventsManager;
+
+ /**
+ * Latest DI build
+ */
+ static protected $_default;
+
+
+ /**
+ * Phalcon\Di constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the internal event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setInternalEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getInternalEventsManager() {}
+
+ /**
+ * Registers a service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function set($name, $definition, $shared = false) {}
+
+ /**
+ * Registers an "always shared" service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setShared($name, $definition) {}
+
+ /**
+ * Removes a service in the services container
+ *
+ * @param string $name
+ */
+ public function remove($name) {}
+
+ /**
+ * Attempts to register a service in the services container
+ * Only is successful if a service hasn"t been registered previously
+ * with the same name
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return bool|\Phalcon\Di\ServiceInterface
+ */
+ public function attempt($name, $definition, $shared = false) {}
+
+ /**
+ * Sets a service using a raw Phalcon\Di\Service definition
+ *
+ * @param string $name
+ * @param mixed $rawDefinition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setRaw($name, \Phalcon\Di\ServiceInterface $rawDefinition) {}
+
+ /**
+ * Returns a service definition without resolving
+ *
+ * @param string $name
+ */
+ public function getRaw($name) {}
+
+ /**
+ * Returns a Phalcon\Di\Service instance
+ *
+ * @param string $name
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function getService($name) {}
+
+ /**
+ * Resolves the service based on its configuration
+ *
+ * @param string $name
+ * @param mixed $parameters
+ */
+ public function get($name, $parameters = null) {}
+
+ /**
+ * Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
+ *
+ * @param string $name
+ * @param array $parameters
+ * @return mixed
+ */
+ public function getShared($name, $parameters = null) {}
+
+ /**
+ * Check whether the DI contains a service by a name
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Check whether the last service obtained via getShared produced a fresh instance or an existing one
+ *
+ * @return bool
+ */
+ public function wasFreshInstance() {}
+
+ /**
+ * Return the services registered in the DI
+ *
+ * @return \Phalcon\Di\Service
+ */
+ public function getServices() {}
+
+ /**
+ * Check if a service is registered using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetExists($name) {}
+
+ /**
+ * Allows to register a shared service using the array syntax
+ *
+ * $di["request"] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return boolean
+ */
+ public function offsetSet($name, $definition) {}
+
+ /**
+ * Allows to obtain a shared service using the array syntax
+ *
+ * var_dump($di["request"]);
+ *
+ *
+ * @param string $name
+ * @return mixed
+ */
+ public function offsetGet($name) {}
+
+ /**
+ * Removes a service from the services container using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetUnset($name) {}
+
+ /**
+ * Magic method to get or set services using setters/getters
+ *
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ public function __call($method, $arguments = null) {}
+
+ /**
+ * Set a default dependency injection container to be obtained into static methods
+ *
+ * @param mixed $dependencyInjector
+ */
+ public static function setDefault(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Return the lastest DI created
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public static function getDefault() {}
+
+ /**
+ * Resets the internal default DI
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/DiInterface.php b/ide/2.0.4/Phalcon/DiInterface.php
new file mode 100644
index 000000000..65bae52fe
--- /dev/null
+++ b/ide/2.0.4/Phalcon/DiInterface.php
@@ -0,0 +1,134 @@
+
+ * $this->dispatcher->forward(array("controller" => "posts", "action" => "index"));
+ *
+ *
+ * @param array $forward
+ */
+ public function forward($forward) {}
+
+ /**
+ * Check if the current executed action was forwarded by another one
+ *
+ * @return bool
+ */
+ public function wasForwarded() {}
+
+ /**
+ * Possible class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getHandlerClass() {}
+
+ /**
+ * Set empty properties to their defaults (where defaults are available)
+ */
+ protected function _resolveEmptyProperties() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/DispatcherInterface.php b/ide/2.0.4/Phalcon/DispatcherInterface.php
new file mode 100644
index 000000000..1b5a292cc
--- /dev/null
+++ b/ide/2.0.4/Phalcon/DispatcherInterface.php
@@ -0,0 +1,120 @@
+
+ * $escaper = new \Phalcon\Escaper();
+ * $escaped = $escaper->escapeCss("font-family:
+ * $escaper->setEncoding('utf-8');
+ *
+ *
+ * @param string $encoding
+ */
+ public function setEncoding($encoding) {}
+
+ /**
+ * Returns the internal encoding used by the escaper
+ *
+ * @return string
+ */
+ public function getEncoding() {}
+
+ /**
+ * Sets the HTML quoting type for htmlspecialchars
+ *
+ * $escaper->setHtmlQuoteType(ENT_XHTML);
+ *
+ *
+ * @param int $quoteType
+ */
+ public function setHtmlQuoteType($quoteType) {}
+
+ /**
+ * Detect the character encoding of a string to be handled by an encoder
+ * Special-handling for chr(172) and chr(128) to chr(159) which fail to be detected by mb_detect_encoding()
+ *
+ * @param string $str
+ * @return string|null
+ */
+ public final function detectEncoding($str) {}
+
+ /**
+ * Utility to normalize a string's encoding to UTF-32.
+ *
+ * @param string $str
+ * @return string
+ */
+ public final function normalizeEncoding($str) {}
+
+ /**
+ * Escapes a HTML string. Internally uses htmlspecialchars
+ *
+ * @param string $text
+ * @return string
+ */
+ public function escapeHtml($text) {}
+
+ /**
+ * Escapes a HTML attribute string
+ *
+ * @param string $attribute
+ * @return string
+ */
+ public function escapeHtmlAttr($attribute) {}
+
+ /**
+ * Escape CSS strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $css
+ * @return string
+ */
+ public function escapeCss($css) {}
+
+ /**
+ * Escape javascript strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $js
+ * @return string
+ */
+ public function escapeJs($js) {}
+
+ /**
+ * Escapes a URL. Internally uses rawurlencode
+ *
+ * @param string $url
+ * @return string
+ */
+ public function escapeUrl($url) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/EscaperInterface.php b/ide/2.0.4/Phalcon/EscaperInterface.php
new file mode 100644
index 000000000..e8718dea2
--- /dev/null
+++ b/ide/2.0.4/Phalcon/EscaperInterface.php
@@ -0,0 +1,73 @@
+
+ * $filter = new \Phalcon\Filter();
+ * $filter->sanitize("some(one)@exa\\mple.com", "email"); // returns "someone@example.com"
+ * $filter->sanitize("hello<<", "string"); // returns "hello"
+ * $filter->sanitize("!100a019", "int"); // returns "100019"
+ * $filter->sanitize("!100a019.01a", "float"); // returns "100019.01"
+ *
+ */
+class Filter implements \Phalcon\FilterInterface
+{
+
+ const FILTER_EMAIL = "email";
+
+
+ const FILTER_ABSINT = "absint";
+
+
+ const FILTER_INT = "int";
+
+
+ const FILTER_INT_CAST = "int!";
+
+
+ const FILTER_STRING = "string";
+
+
+ const FILTER_FLOAT = "float";
+
+
+ const FILTER_FLOAT_CAST = "float!";
+
+
+ const FILTER_ALPHANUM = "alphanum";
+
+
+ const FILTER_TRIM = "trim";
+
+
+ const FILTER_STRIPTAGS = "striptags";
+
+
+ const FILTER_LOWER = "lower";
+
+
+ const FILTER_UPPER = "upper";
+
+
+ protected $_filters;
+
+
+ /**
+ * Adds a user-defined filter
+ *
+ * @param string $name
+ * @param mixed $handler
+ * @return Filter
+ */
+ public function add($name, $handler) {}
+
+ /**
+ * Sanitizes a value with a specified single or set of filters
+ *
+ * @param mixed $value
+ * @param mixed $filters
+ * @param bool $noRecursive
+ */
+ public function sanitize($value, $filters, $noRecursive = false) {}
+
+ /**
+ * Internal sanitize wrapper to filter_var
+ *
+ * @param mixed $value
+ * @param string $filter
+ */
+ protected function _sanitize($value, $filter) {}
+
+ /**
+ * Return the user-defined filters in the instance
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/FilterInterface.php b/ide/2.0.4/Phalcon/FilterInterface.php
new file mode 100644
index 000000000..5ebd2ee21
--- /dev/null
+++ b/ide/2.0.4/Phalcon/FilterInterface.php
@@ -0,0 +1,37 @@
+
+ * $flash->success("The record was successfully deleted");
+ * $flash->error("Cannot open the file");
+ *
+ */
+abstract class Flash
+{
+
+ protected $_cssClasses;
+
+
+ protected $_implicitFlush = true;
+
+
+ protected $_automaticHtml = true;
+
+
+<<<<<<< HEAD
+ protected $_messages;
+
+
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ /**
+ * Phalcon\Flash constructor
+ *
+ * @param mixed $cssClasses
+ */
+ public function __construct($cssClasses = null) {}
+
+ /**
+ * Set whether the output must be implicitly flushed to the output or returned as string
+ *
+ * @param bool $implicitFlush
+ * @return \Phalcon\FlashInterface
+ */
+ public function setImplicitFlush($implicitFlush) {}
+
+ /**
+ * Set if the output must be implicitly formatted with HTML
+ *
+ * @param bool $automaticHtml
+ * @return \Phalcon\FlashInterface
+ */
+ public function setAutomaticHtml($automaticHtml) {}
+
+ /**
+ * Set an array with CSS classes to format the messages
+ *
+ * @param array $cssClasses
+ * @return \Phalcon\FlashInterface
+ */
+ public function setCssClasses($cssClasses) {}
+
+ /**
+ * Shows a HTML error message
+ *
+ * $flash->error('This is an error');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function error($message) {}
+
+ /**
+ * Shows a HTML notice/information message
+ *
+ * $flash->notice('This is an information');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function notice($message) {}
+
+ /**
+ * Shows a HTML success message
+ *
+ * $flash->success('The process was finished successfully');
+ *
+ *
+ * @param string $message
+ * @return string
+ */
+ public function success($message) {}
+
+ /**
+ * Shows a HTML warning message
+ *
+ * $flash->warning('Hey, this is important');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function warning($message) {}
+
+ /**
+ * Outputs a message formatting it with HTML
+ *
+ * $flash->outputMessage('error', message);
+ *
+ *
+ * @param string $type
+ * @param string|array $message
+ */
+ public function outputMessage($type, $message) {}
+
+<<<<<<< HEAD
+ /**
+ * Clears accumulated messages when implicit flush is disabled
+ */
+ public function clear() {}
+
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/FlashInterface.php b/ide/2.0.4/Phalcon/FlashInterface.php
new file mode 100644
index 000000000..86ca19753
--- /dev/null
+++ b/ide/2.0.4/Phalcon/FlashInterface.php
@@ -0,0 +1,48 @@
+
+ * //Creates the autoloader
+ * $loader = new Loader();
+ * //Register some namespaces
+ * $loader->registerNamespaces(array(
+ * 'Example\Base' => 'vendor/example/base/',
+ * 'Example\Adapter' => 'vendor/example/adapter/',
+ * 'Example' => 'vendor/example/'
+ * ));
+ * //register autoloader
+ * $loader->register();
+ * //Requiring this class will automatically include file vendor/example/adapter/Some.php
+ * $adapter = Example\Adapter\Some();
+ *
+ */
+class Loader implements \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_eventsManager = null;
+
+
+ protected $_foundPath = null;
+
+
+ protected $_checkedPath = null;
+
+
+ protected $_prefixes = null;
+
+
+ protected $_classes = null;
+
+
+ protected $_extensions;
+
+
+ protected $_namespaces = null;
+
+
+ protected $_directories = null;
+
+
+ protected $_registered = false;
+
+
+ /**
+ * Phalcon\Loader constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the events manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets an array of file extensions that the loader must try in each attempt to locate the file
+ *
+ * @param array $extensions
+ * @return Loader
+ */
+ public function setExtensions($extensions) {}
+
+ /**
+ * Returns the file extensions registered in the loader
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register namespaces and their related directories
+ *
+ * @param array $namespaces
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerNamespaces($namespaces, $merge = false) {}
+
+ /**
+ * Returns the namespaces currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getNamespaces() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $prefixes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerPrefixes($prefixes, $merge = false) {}
+
+ /**
+ * Returns the prefixes currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getPrefixes() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $directories
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerDirs($directories, $merge = false) {}
+
+ /**
+ * Returns the directories currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getDirs() {}
+
+ /**
+ * Register classes and their locations
+ *
+ * @param array $classes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerClasses($classes, $merge = false) {}
+
+ /**
+ * Returns the class-map currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getClasses() {}
+
+ /**
+ * Register the autoload method
+ *
+ * @return Loader
+ */
+ public function register() {}
+
+ /**
+ * Unregister the autoload method
+ *
+ * @return Loader
+ */
+ public function unregister() {}
+
+ /**
+ * Autoloads the registered classes
+ *
+ * @param string $className
+ * @return bool
+ */
+ public function autoLoad($className) {}
+
+ /**
+ * Get the path when a class was found
+ *
+ * @return string
+ */
+ public function getFoundPath() {}
+
+ /**
+ * Get the path the loader is checking for a path
+ *
+ * @return string
+ */
+ public function getCheckedPath() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Logger.php b/ide/2.0.4/Phalcon/Logger.php
new file mode 100644
index 000000000..6ea41067c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Logger.php
@@ -0,0 +1,53 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+abstract class Logger
+{
+
+ const SPECIAL = 9;
+
+
+ const CUSTOM = 8;
+
+
+ const DEBUG = 7;
+
+
+ const INFO = 6;
+
+
+ const NOTICE = 5;
+
+
+ const WARNING = 4;
+
+
+ const ERROR = 3;
+
+
+ const ALERT = 2;
+
+
+ const CRITICAL = 1;
+
+
+ const EMERGENCE = 0;
+
+
+ const EMERGENCY = 0;
+
+
+}
diff --git a/ide/2.0.4/Phalcon/Registry.php b/ide/2.0.4/Phalcon/Registry.php
new file mode 100644
index 000000000..560353724
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Registry.php
@@ -0,0 +1,150 @@
+
+ * $registry = new \Phalcon\Registry();
+ * // Set value
+ * $registry->something = 'something';
+ * // or
+ * $registry['something'] = 'something';
+ * // Get value
+ * $value = $registry->something;
+ * // or
+ * $value = $registry['something'];
+ * // Check if the key exists
+ * $exists = isset($registry->something);
+ * // or
+ * $exists = isset($registry['something']);
+ * // Unset
+ * unset($registry->something);
+ * // or
+ * unset($registry['something']);
+ *
+ * In addition to ArrayAccess, Phalcon\Registry also implements Countable
+ * (count($registry) will return the number of elements in the registry),
+ * Serializable and Iterator (you can iterate over the registry
+ * using a foreach loop) interfaces. For PHP 5.4 and higher, JsonSerializable
+ * interface is implemented.
+ * Phalcon\Registry is very fast (it is typically faster than any userspace
+ * implementation of the registry); however, this comes at a price:
+ * Phalcon\Registry is a final class and cannot be inherited from.
+ * Though Phalcon\Registry exposes methods like __get(), offsetGet(), count() etc,
+ * it is not recommended to invoke them manually (these methods exist mainly to
+ * match the interfaces the registry implements): $registry->__get('property')
+ * is several times slower than $registry->property.
+ * Internally all the magic methods (and interfaces except JsonSerializable)
+ * are implemented using object handlers or similar techniques: this allows
+ * to bypass relatively slow method calls.
+ */
+final class Registry implements \ArrayAccess, \Countable, \Iterator
+{
+
+ protected $_data;
+
+
+ /**
+ * Registry constructor
+ */
+ public final function __construct() {}
+
+ /**
+ * Checks if the element is present in the registry
+ *
+ * @param string $offset
+ * @return bool
+ */
+ public final function offsetExists($offset) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $offset
+ * @return variable
+ */
+ public final function offsetGet($offset) {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $offset
+ * @param mixed $value
+ */
+ public final function offsetSet($offset, $value) {}
+
+ /**
+ * Unsets an element in the registry
+ *
+ * @param string $offset
+ */
+ public final function offsetUnset($offset) {}
+
+ /**
+ * Checks how many elements are in the register
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Moves cursor to next row in the registry
+ */
+ public final function next() {}
+
+ /**
+ * Gets pointer number of active row in the registry
+ *
+ * @return int
+ */
+ public final function key() {}
+
+ /**
+ * Rewinds the registry cursor to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Checks if the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Obtains the current value in the internal iterator
+ */
+ public function current() {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public final function __set($key, $value) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $key
+ * @return variable
+ */
+ public final function __get($key) {}
+
+ /**
+ * @param string $key
+ * @return bool
+ */
+ public final function __isset($key) {}
+
+ /**
+ * @param string $key
+ */
+ public final function __unset($key) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Security.php b/ide/2.0.4/Phalcon/Security.php
new file mode 100644
index 000000000..0a44a9e35
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Security.php
@@ -0,0 +1,201 @@
+
+ * $login = $this->request->getPost('login');
+ * $password = $this->request->getPost('password');
+ * $user = Users::findFirstByLogin($login);
+ * if ($user) {
+ * if ($this->security->checkHash($password, $user->password)) {
+ * //The password is valid
+ * }
+ * }
+ *
+ */
+class Security implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const CRYPT_DEFAULT = 0;
+
+
+ const CRYPT_STD_DES = 1;
+
+
+ const CRYPT_EXT_DES = 2;
+
+
+ const CRYPT_MD5 = 3;
+
+
+ const CRYPT_BLOWFISH = 4;
+
+
+ const CRYPT_BLOWFISH_X = 5;
+
+
+ const CRYPT_BLOWFISH_Y = 6;
+
+
+ const CRYPT_SHA256 = 7;
+
+
+ const CRYPT_SHA512 = 8;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_workFactor = 8;
+
+
+ protected $_numberBytes = 16;
+
+
+ protected $_tokenKeySessionID = "$PHALCON/CSRF/KEY$";
+
+
+ protected $_tokenValueSessionID = "$PHALCON/CSRF$";
+
+
+ protected $_csrf;
+
+
+ protected $_defaultHash;
+
+
+ /**
+ * @param mixed $workFactor
+ */
+ public function setWorkFactor($workFactor) {}
+
+
+ public function getWorkFactor() {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @param long $randomBytes
+ */
+ public function setRandomBytes($randomBytes) {}
+
+ /**
+ * Returns a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @return string
+ */
+ public function getRandomBytes() {}
+
+ /**
+ * Generate a >22-length pseudo random string to be used as salt for passwords
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getSaltBytes($numberBytes = 0) {}
+
+ /**
+ * Creates a password hash using bcrypt with a pseudo random salt
+ *
+ * @param string $password
+ * @param int $workFactor
+ * @return string
+ */
+ public function hash($password, $workFactor = 0) {}
+
+ /**
+ * Checks a plain text password and its hash version to check if the password matches
+ *
+ * @param string $password
+ * @param string $passwordHash
+ * @param int $maxPassLength
+ * @return bool
+ */
+ public function checkHash($password, $passwordHash, $maxPassLength = 0) {}
+
+ /**
+ * Checks if a password hash is a valid bcrypt's hash
+ *
+ * @param string $passwordHash
+ * @return bool
+ */
+ public function isLegacyHash($passwordHash) {}
+
+ /**
+ * Generates a pseudo random token key to be used as input's name in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getTokenKey($numberBytes = null) {}
+
+ /**
+ * Generates a pseudo random token value to be used as input's value in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getToken($numberBytes = null) {}
+
+ /**
+ * Check if the CSRF token sent in the request is the same that the current in session
+ *
+ * @param mixed $tokenKey
+ * @param mixed $tokenValue
+ * @param bool $destroyIfValid
+ * @return bool
+ */
+ public function checkToken($tokenKey = null, $tokenValue = null, $destroyIfValid = true) {}
+
+ /**
+ * Returns the value of the CSRF token in session
+ *
+ * @return string
+ */
+ public function getSessionToken() {}
+
+ /**
+ * Removes the value of the CSRF token and key from session
+ */
+ public function destroyToken() {}
+
+ /**
+ * Computes a HMAC
+ *
+ * @param string $data
+ * @param string $key
+ * @param string $algo
+ * @param boolean $raw
+ */
+ public function computeHmac($data, $key, $algo, $raw = false) {}
+
+ /**
+ * Sets the default hash
+ *
+ * @param mixed $defaultHash
+ */
+ public function setDefaultHash($defaultHash) {}
+
+ /**
+ * Sets the default hash
+ */
+ public function getDefaultHash() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Session.php b/ide/2.0.4/Phalcon/Session.php
new file mode 100644
index 000000000..76e72cff4
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Session.php
@@ -0,0 +1,23 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+abstract class Session
+{
+
+}
diff --git a/ide/2.0.4/Phalcon/Tag.php b/ide/2.0.4/Phalcon/Tag.php
new file mode 100644
index 000000000..ee232b3b2
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Tag.php
@@ -0,0 +1,718 @@
+
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefault("name", "peter");
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function setDefault($id, $value) {}
+
+ /**
+ * Assigns default values to generated tags by helpers
+ *
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefaults(array("name" => "peter"));
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param array $values
+ * @param bool $merge
+ */
+ public static function setDefaults($values, $merge = false) {}
+
+ /**
+ * Alias of Phalcon\Tag::setDefault
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function displayTo($id, $value) {}
+
+ /**
+ * Check if a helper has a default value set using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @return boolean
+ */
+ public static function hasValue($name) {}
+
+ /**
+ * Every helper calls this function to check whether a component has a predefined
+ * value using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @param array $params
+ * @return mixed
+ */
+ public static function getValue($name, $params = null) {}
+
+ /**
+ * Resets the request and internal values to avoid those fields will have any default value
+ */
+ public static function resetInput() {}
+
+ /**
+ * Builds a HTML A tag using framework conventions
+ *
+ * echo Phalcon\Tag::linkTo("signup/register", "Register Here!");
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!"));
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!", "class" => "btn-primary"));
+ * echo Phalcon\Tag::linkTo("http://phalconphp.com/", "Phalcon", FALSE);
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", FALSE));
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", "local" =>FALSE));
+ *
+ *
+ * @param array|string $parameters
+ * @param string $text
+ * @param boolean $local
+ * @return string
+ */
+ public static function linkTo($parameters, $text = null, $local = true) {}
+
+ /**
+ * Builds generic INPUT tags
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @param bool $asValue
+ * @param $boolean asValue
+ * @return string
+ */
+ static protected final function _inputField($type, $parameters, $asValue = false) {}
+
+ /**
+ * Builds INPUT tags that implements the checked attribute
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @return string
+ */
+ static protected final function _inputFieldChecked($type, $parameters) {}
+
+ /**
+ * Builds a HTML input[type="color"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function colorField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="text"] tag
+ *
+ * echo Phalcon\Tag::textField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="number"] tag
+ *
+ * echo Phalcon\Tag::numericField(array("price", "min" => "1", "max" => "5"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function numericField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="range"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function rangeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="email"] tag
+ *
+ * echo Phalcon\Tag::emailField("email");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function emailField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="date"] tag
+ *
+ * echo Phalcon\Tag::dateField(array("born", "value" => "14-12-1980"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function dateField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime-local"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeLocalField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="month"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function monthField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="time"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function timeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="week"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function weekField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="password"] tag
+ *
+ * echo Phalcon\Tag::passwordField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function passwordField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="hidden"] tag
+ *
+ * echo Phalcon\Tag::hiddenField(array("name", "value" => "mike"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function hiddenField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="file"] tag
+ *
+ * echo Phalcon\Tag::fileField("file");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function fileField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="search"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function searchField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="tel"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function telField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="url"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function urlField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="check"] tag
+ *
+ * echo Phalcon\Tag::checkField(array("terms", "value" => "Y"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function checkField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="radio"] tag
+ *
+ * echo Phalcon\Tag::radioField(array("weather", "value" => "hot"))
+ *
+ * Volt syntax:
+ *
+ * {{ radio_field("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function radioField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="image"] tag
+ *
+ * echo Phalcon\Tag::imageInput(array("src" => "/img/button.png"));
+ *
+ * Volt syntax:
+ *
+ * {{ image_input("src": "/img/button.png") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function imageInput($parameters) {}
+
+ /**
+ * Builds a HTML input[type="submit"] tag
+ *
+ * echo Phalcon\Tag::submitButton("Save")
+ *
+ * Volt syntax:
+ *
+ * {{ submit_button("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function submitButton($parameters) {}
+
+ /**
+ * Builds a HTML SELECT tag using a PHP array for options
+ *
+ * echo Phalcon\Tag::selectStatic("status", array("A" => "Active", "I" => "Inactive"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function selectStatic($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML SELECT tag using a Phalcon\Mvc\Model resultset as options
+ *
+ * echo Phalcon\Tag::select(array(
+ * "robotId",
+ * Robots::find("type = "mechanical""),
+ * "using" => array("id", "name")
+ * ));
+ *
+ * Volt syntax:
+ *
+ * {{ select("robotId", robots, "using": ["id", "name"]) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function select($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML TEXTAREA tag
+ *
+ * echo Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4))
+ *
+ * Volt syntax:
+ *
+ * {{ text_area("comments", "cols": 10, "rows": 4) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textArea($parameters) {}
+
+ /**
+ * Builds a HTML FORM tag
+ *
+ * echo Phalcon\Tag::form("posts/save");
+ * echo Phalcon\Tag::form(array("posts/save", "method" => "post"));
+ *
+ * Volt syntax:
+ *
+ * {{ form("posts/save") }}
+ * {{ form("posts/save", "method": "post") }}
+ *
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function form($parameters) {}
+
+ /**
+ * Builds a HTML close FORM tag
+ *
+ * @return string
+ */
+ public static function endForm() {}
+
+ /**
+ * Set the title of view content
+ *
+ * Phalcon\Tag::setTitle("Welcome to my Page");
+ *
+ *
+ * @param string $title
+ */
+ public static function setTitle($title) {}
+
+ /**
+ * Set the title separator of view content
+ *
+ * Phalcon\Tag::setTitleSeparator("-");
+ *
+ *
+ * @param string $titleSeparator
+ */
+ public static function setTitleSeparator($titleSeparator) {}
+
+ /**
+ * Appends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function appendTitle($title) {}
+
+ /**
+ * Prepends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function prependTitle($title) {}
+
+ /**
+ * Gets the current document title
+ *
+ * echo Phalcon\Tag::getTitle();
+ *
+ *
+ * {{ get_title() }}
+ *
+ *
+ * @param bool $tags
+ * @return string
+ */
+ public static function getTitle($tags = true) {}
+
+ /**
+ * Gets the current document title separator
+ *
+ * echo Phalcon\Tag::getTitleSeparator();
+ *
+ *
+ * {{ get_title_separator() }}
+ *
+ *
+ * @return string
+ */
+ public static function getTitleSeparator() {}
+
+ /**
+ * Builds a LINK[rel="stylesheet"] tag
+ *
+ * echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
+ * echo Phalcon\Tag::stylesheetLink("css/style.css");
+ *
+ * Volt Syntax:
+ *
+ * {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }}
+ * {{ stylesheet_link("css/style.css") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function stylesheetLink($parameters = null, $local = true) {}
+
+ /**
+ * Builds a SCRIPT[type="javascript"] tag
+ *
+ * echo Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false);
+ * echo Phalcon\Tag::javascriptInclude("javascript/jquery.js");
+ *
+ * Volt syntax:
+ *
+ * {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false) }}
+ * {{ javascript_include("javascript/jquery.js") }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function javascriptInclude($parameters = null, $local = true) {}
+
+ /**
+ * Builds HTML IMG tags
+ *
+ * echo Phalcon\Tag::image("img/bg.png");
+ * echo Phalcon\Tag::image(array("img/photo.jpg", "alt" => "Some Photo"));
+ *
+ * Volt Syntax:
+ *
+ * {{ image("img/bg.png") }}
+ * {{ image("img/photo.jpg", "alt": "Some Photo") }}
+ * {{ image("http://static.mywebsite.com/img/bg.png", false) }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function image($parameters = null, $local = true) {}
+
+ /**
+ * Converts texts into URL-friendly titles
+ *
+ * echo Phalcon\Tag::friendlyTitle("These are big important news", "-")
+ *
+ *
+ * @param string $text
+ * @param string $separator
+ * @param boolean $lowercase
+ * @param mixed $replace
+ * @return text
+ */
+ public static function friendlyTitle($text, $separator = "-", $lowercase = true, $replace = null) {}
+
+ /**
+ * Set the document type of content
+ *
+ * @param int $doctype
+ */
+ public static function setDocType($doctype) {}
+
+ /**
+ * Get the document type declaration of content
+ *
+ * @return string
+ */
+ public static function getDocType() {}
+
+ /**
+ * Builds a HTML tag
+ *
+ * echo Phalcon\Tag::tagHtml(name, parameters, selfClose, onlyStart, eol);
+ *
+ *
+ * @param string $tagName
+ * @param array $parameters
+ * @param boolean $selfClose
+ * @param boolean $onlyStart
+ * @param boolean $useEol
+ * @return string
+ */
+ public static function tagHtml($tagName, $parameters = null, $selfClose = false, $onlyStart = false, $useEol = false) {}
+
+ /**
+ * Builds a HTML tag closing tag
+ *
+ * echo Phalcon\Tag::tagHtmlClose("script", true)
+ *
+ *
+ * @param string $tagName
+ * @param bool $useEol
+ * @return string
+ */
+ public static function tagHtmlClose($tagName, $useEol = false) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/Text.php b/ide/2.0.4/Phalcon/Text.php
new file mode 100644
index 000000000..d3a7e4430
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Text.php
@@ -0,0 +1,174 @@
+
+ * echo Phalcon\Text::camelize('coco_bongo'); //CocoBongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function camelize($str) {}
+
+ /**
+ * Uncamelize strings which are camelized
+ *
+ * echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function uncamelize($str) {}
+
+ /**
+ * Adds a number to a string or increment that number if it already is defined
+ *
+ * echo Phalcon\Text::increment("a"); // "a_1"
+ * echo Phalcon\Text::increment("a_1"); // "a_2"
+ *
+ *
+ * @param string $str
+ * @param mixed $separator
+ * @return string
+ */
+ public static function increment($str, $separator = null) {}
+
+ /**
+ * Generates a random string based on the given type. Type is one of the RANDOM_* constants
+ *
+ * echo Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz"
+ *
+ *
+ * @param int $type
+ * @param long $length
+ * @return string
+ */
+ public static function random($type = 0, $length = 8) {}
+
+ /**
+ * Check if a string starts with a given string
+ *
+ * echo Phalcon\Text::startsWith("Hello", "He"); // true
+ * echo Phalcon\Text::startsWith("Hello", "he", false); // false
+ * echo Phalcon\Text::startsWith("Hello", "he"); // true
+ *
+ *
+ * @param string $str
+ * @param string $start
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function startsWith($str, $start, $ignoreCase = true) {}
+
+ /**
+ * Check if a string ends with a given string
+ *
+ * echo Phalcon\Text::endsWith("Hello", "llo"); // true
+ * echo Phalcon\Text::endsWith("Hello", "LLO", false); // false
+ * echo Phalcon\Text::endsWith("Hello", "LLO"); // true
+ *
+ *
+ * @param string $str
+ * @param string $end
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function endsWith($str, $end, $ignoreCase = true) {}
+
+ /**
+ * Lowercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::lower("HELLO"); // hello
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function lower($str, $encoding = "UTF-8") {}
+
+ /**
+ * Uppercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::upper("hello"); // HELLO
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function upper($str, $encoding = "UTF-8") {}
+
+ /**
+ * Reduces multiple slashes in a string to single slashes
+ *
+ * echo Phalcon\Text::reduceSlashes("foo//bar/baz"); // foo/bar/baz
+ * echo Phalcon\Text::reduceSlashes("http://foo.bar///baz/buz"); // http://foo.bar/baz/buz
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function reduceSlashes($str) {}
+
+ /**
+ * Concatenates strings using the separator only once without duplication in places concatenation
+ *
+ * $str = Phalcon\Text::concat("/", "/tmp/", "/folder_1/", "/folder_2", "folder_3/");
+ * echo $str; // /tmp/folder_1/folder_2/folder_3/
+ *
+ *
+ * @param string $separator
+ * @param string $a
+ * @param string $b
+ * @param string $...N
+ * @return string
+ */
+ public static function concat() {}
+
+<<<<<<< HEAD
+ /**
+ * Generates random text in accordance with the template
+ *
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob
+ *
+ *
+ * @param string $text
+ * @param string $leftDelimiter
+ * @param string $rightDelimiter
+ * @param string $separator
+ * @return string
+ */
+ public static function dynamic($text, $leftDelimiter = "{", $rightDelimiter = "}", $separator = "|") {}
+
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/Translate.php b/ide/2.0.4/Phalcon/Translate.php
new file mode 100644
index 000000000..e0cf39581
--- /dev/null
+++ b/ide/2.0.4/Phalcon/Translate.php
@@ -0,0 +1,13 @@
+
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ */
+ const VERSION_MAJOR = 0;
+
+ /**
+ * The constant referencing the major version. Returns 1
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MEDIUM);
+ *
+ */
+ const VERSION_MEDIUM = 1;
+
+ /**
+ * The constant referencing the major version. Returns 2
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MINOR);
+ *
+ */
+ const VERSION_MINOR = 2;
+
+ /**
+ * The constant referencing the major version. Returns 3
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL);
+ *
+ */
+ const VERSION_SPECIAL = 3;
+
+ /**
+ * The constant referencing the major version. Returns 4
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL_NUMBER);
+ *
+ */
+ const VERSION_SPECIAL_NUMBER = 4;
+
+
+ /**
+ * Area where the version number is set. The format is as follows:
+ * ABBCCDE
+ * A - Major version
+ * B - Med version (two digits)
+ * C - Min version (two digits)
+ * D - Special release: 1 = Alpha, 2 = Beta, 3 = RC, 4 = Stable
+ * E - Special release version i.e. RC1, Beta2 etc.
+ *
+ * @return array
+ */
+ protected static function _getVersion() {}
+
+ /**
+ * Translates a number to a special release
+ * If Special release = 1 this function will return ALPHA
+ *
+ * @param int $special
+ * @return string
+ */
+ protected final static function _getSpecial($special) {}
+
+ /**
+ * Returns the active version (string)
+ *
+ * echo Phalcon\Version::get();
+ *
+ *
+ * @return string
+ */
+ public static function get() {}
+
+ /**
+ * Returns the numeric active version
+ *
+ * echo Phalcon\Version::getId();
+ *
+ *
+ * @return string
+ */
+ public static function getId() {}
+
+ /**
+ * Returns a specific part of the version. If the wrong parameter is passed
+ * it will return the full version
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ *
+ * @param int $part
+ * @return string
+ */
+ public static function getPart($part) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/acl/Adapter.php b/ide/2.0.4/Phalcon/acl/Adapter.php
new file mode 100644
index 000000000..d261e1917
--- /dev/null
+++ b/ide/2.0.4/Phalcon/acl/Adapter.php
@@ -0,0 +1,103 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * $acl->setDefaultAction(Phalcon\Acl::DENY);
+ * //Register roles
+ * $roles = array(
+ * 'users' => new \Phalcon\Acl\Role('Users'),
+ * 'guests' => new \Phalcon\Acl\Role('Guests')
+ * );
+ * foreach ($roles as $role) {
+ * $acl->addRole($role);
+ * }
+ * //Private area resources
+ * $privateResources = array(
+ * 'companies' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'products' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'invoices' => array('index', 'profile')
+ * );
+ * foreach ($privateResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Public area resources
+ * $publicResources = array(
+ * 'index' => array('index'),
+ * 'about' => array('index'),
+ * 'session' => array('index', 'register', 'start', 'end'),
+ * 'contact' => array('index', 'send')
+ * );
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Grant access to public areas to both users and guests
+ * foreach ($roles as $role){
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->allow($role->getName(), $resource, '*');
+ * }
+ * }
+ * //Grant access to private area to role Users
+ * foreach ($privateResources as $resource => $actions) {
+ * foreach ($actions as $action) {
+ * $acl->allow('Users', $resource, $action);
+ * }
+ * }
+ *
+ */
+class Memory extends \Phalcon\Acl\Adapter
+{
+ /**
+ * Roles Names
+ *
+ * @var mixed
+ */
+ protected $_rolesNames;
+
+ /**
+ * Roles
+ *
+ * @var mixed
+ */
+ protected $_roles;
+
+ /**
+ * Resource Names
+ *
+ * @var mixed
+ */
+ protected $_resourcesNames;
+
+ /**
+ * Resources
+ *
+ * @var mixed
+ */
+ protected $_resources;
+
+ /**
+ * Access
+ *
+ * @var mixed
+ */
+ protected $_access;
+
+ /**
+ * Role Inherits
+ *
+ * @var mixed
+ */
+ protected $_roleInherits;
+
+ /**
+ * Access List
+ *
+ * @var mixed
+ */
+ protected $_accessList;
+
+
+ /**
+ * Phalcon\Acl\Adapter\Memory constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Adds a role to the ACL list. Second parameter allows inheriting access data from other existing role
+ * Example:
+ *
+ * $acl->addRole(new Phalcon\Acl\Role('administrator'), 'consultant');
+ * $acl->addRole('administrator', 'consultant');
+ *
+ *
+ * @param mixed $role
+ * @param array|string $accessInherits
+ * @return bool
+ */
+ public function addRole($role, $accessInherits = null) {}
+
+ /**
+ * Do a role inherit from another existing role
+ *
+ * @param string $roleName
+ * @param mixed $roleToInherit
+ * @return bool
+ */
+ public function addInherit($roleName, $roleToInherit) {}
+
+ /**
+ * Check whether role exist in the roles list
+ *
+ * @param string $roleName
+ * @return bool
+ */
+ public function isRole($roleName) {}
+
+ /**
+ * Check whether resource exist in the resources list
+ *
+ * @param string $resourceName
+ * @return bool
+ */
+ public function isResource($resourceName) {}
+
+ /**
+ * Adds a resource to the ACL list
+ * Access names can be a particular action, by example
+ * search, update, delete, etc or a list of them
+ * Example:
+ *
+ * //Add a resource to the the list allowing access to an action
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), 'search');
+ * $acl->addResource('customers', 'search');
+ * //Add a resource with an access list
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), array('create', 'search'));
+ * $acl->addResource('customers', array('create', 'search'));
+ *
+ *
+ * @param \Phalcon\Acl\Resource|string $resourceValue
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResource($resourceValue, $accessList) {}
+
+ /**
+ * Adds access to resources
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Removes an access from a resource
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ */
+ public function dropResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Checks if a role has access to a resource
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ * @param mixed $action
+ */
+ protected function _allowOrDeny($roleName, $resourceName, $access, $action) {}
+
+ /**
+ * Allow access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Allow access to guests to search on customers
+ * $acl->allow('guests', 'customers', 'search');
+ * //Allow access to guests to search or create on customers
+ * $acl->allow('guests', 'customers', array('search', 'create'));
+ * //Allow access to any role to browse on products
+ * $acl->allow('*', 'products', 'browse');
+ * //Allow access to any role to browse on any resource
+ * $acl->allow('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function allow($roleName, $resourceName, $access) {}
+
+ /**
+ * Deny access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Deny access to guests to search on customers
+ * $acl->deny('guests', 'customers', 'search');
+ * //Deny access to guests to search or create on customers
+ * $acl->deny('guests', 'customers', array('search', 'create'));
+ * //Deny access to any role to browse on products
+ * $acl->deny('*', 'products', 'browse');
+ * //Deny access to any role to browse on any resource
+ * $acl->deny('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function deny($roleName, $resourceName, $access) {}
+
+ /**
+ * Check whether a role is allowed to access an action from a resource
+ *
+ * //Does andres have access to the customers resource to create?
+ * $acl->isAllowed('andres', 'Products', 'create');
+ * //Do guests have access to any resource to edit?
+ * $acl->isAllowed('guests', '*', 'edit');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param string $access
+ * @return bool
+ */
+ public function isAllowed($roleName, $resourceName, $access) {}
+
+ /**
+ * Return an array with every role registered in the list
+ *
+ * @return \Phalcon\Acl\Role
+ */
+ public function getRoles() {}
+
+ /**
+ * Return an array with every resource registered in the list
+ *
+ * @return \Phalcon\Acl\Resource
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/annotations/Adapter.php b/ide/2.0.4/Phalcon/annotations/Adapter.php
new file mode 100644
index 000000000..19b67c0aa
--- /dev/null
+++ b/ide/2.0.4/Phalcon/annotations/Adapter.php
@@ -0,0 +1,74 @@
+
+ * //Traverse annotations
+ * foreach ($classAnnotations as $annotation) {
+ * echo 'Name=', $annotation->getName(), PHP_EOL;
+ * }
+ * //Check if the annotations has a specific
+ * var_dump($classAnnotations->has('Cacheable'));
+ * //Get an specific annotation in the collection
+ * $annotation = $classAnnotations->get('Cacheable');
+ *
+ */
+class Collection implements \Iterator, \Countable
+{
+
+ protected $_position = 0;
+
+
+ protected $_annotations;
+
+
+ /**
+ * Phalcon\Annotations\Collection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the number of annotations in the collection
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current annotation in the iterator
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current annotation in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Returns the internal annotations as an array
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAnnotations() {}
+
+ /**
+ * Returns the first annotation that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function get($name) {}
+
+ /**
+ * Returns all the annotations that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAll($name) {}
+
+ /**
+ * Check if an annotation exists in a collection
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/annotations/Exception.php b/ide/2.0.4/Phalcon/annotations/Exception.php
new file mode 100644
index 000000000..973db2530
--- /dev/null
+++ b/ide/2.0.4/Phalcon/annotations/Exception.php
@@ -0,0 +1,9 @@
+
+ * //Parse the annotations in a class
+ * $reader = new \Phalcon\Annotations\Reader();
+ * $parsing = reader->parse('MyComponent');
+ * //Create the reflection
+ * $reflection = new \Phalcon\Annotations\Reflection($parsing);
+ * //Get the annotations in the class docblock
+ * $classAnnotations = reflection->getClassAnnotations();
+ *
+ */
+class Reflection
+{
+
+ protected $_reflectionData;
+
+
+ protected $_classAnnotations;
+
+
+ protected $_methodAnnotations;
+
+
+ protected $_propertyAnnotations;
+
+
+ /**
+ * Phalcon\Annotations\Reflection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the annotations found in the class docblock
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getClassAnnotations() {}
+
+ /**
+ * Returns the annotations found in the methods' docblocks
+ *
+ * @return \Phalcon\Annotations\Collection[]
+ */
+ public function getMethodsAnnotations() {}
+
+ /**
+ * Returns the annotations found in the properties' docblocks
+ *
+ * @return \Phalcon\Annotations\Collection[]
+ */
+ public function getPropertiesAnnotations() {}
+
+ /**
+ * Returns the raw parsing intermediate definitions used to construct the reflection
+ *
+ * @return array
+ */
+ public function getReflectionData() {}
+
+ /**
+ * Restores the state of a Phalcon\Annotations\Reflection variable export
+ *
+ * @param mixed $data
+ * @return array
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/annotations/adapter/Apc.php b/ide/2.0.4/Phalcon/annotations/adapter/Apc.php
new file mode 100644
index 000000000..822c0c8a8
--- /dev/null
+++ b/ide/2.0.4/Phalcon/annotations/adapter/Apc.php
@@ -0,0 +1,44 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Apc();
+ *
+ */
+class Apc extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from APC
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/annotations/adapter/Files.php b/ide/2.0.4/Phalcon/annotations/adapter/Files.php
new file mode 100644
index 000000000..9115c2b35
--- /dev/null
+++ b/ide/2.0.4/Phalcon/annotations/adapter/Files.php
@@ -0,0 +1,43 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Files(array(
+ * 'annotationsDir' => 'app/cache/annotations/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_annotationsDir = "./";
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from files
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to files
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/annotations/adapter/Memory.php b/ide/2.0.4/Phalcon/annotations/adapter/Memory.php
new file mode 100644
index 000000000..84ad80c8c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/annotations/adapter/Memory.php
@@ -0,0 +1,35 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Xcache();
+ *
+ */
+class Xcache extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ /**
+ * Reads parsed annotations from XCache
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to XCache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/assets/Collection.php b/ide/2.0.4/Phalcon/assets/Collection.php
new file mode 100644
index 000000000..651683b42
--- /dev/null
+++ b/ide/2.0.4/Phalcon/assets/Collection.php
@@ -0,0 +1,284 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addInlineJs($content, $filter = false, $attributes = null) {}
+
+ /**
+ * Returns the number of elements in the form
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current resource in the iterator
+ *
+ * @return \Phalcon\Assets\Resource
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current element in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Sets the target path of the file for the filtered/join output
+ *
+ * @param string $targetPath
+ * @return Collection
+ */
+ public function setTargetPath($targetPath) {}
+
+ /**
+ * Sets a base source path for all the resources in this collection
+ *
+ * @param string $sourcePath
+ * @return Collection
+ */
+ public function setSourcePath($sourcePath) {}
+
+ /**
+ * Sets a target uri for the generated HTML
+ *
+ * @param string $targetUri
+ * @return Collection
+ */
+ public function setTargetUri($targetUri) {}
+
+ /**
+ * Sets a common prefix for all the resources
+ *
+ * @param string $prefix
+ * @return Collection
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Sets if the collection uses local resources by default
+ *
+ * @param bool $local
+ * @return Collection
+ */
+ public function setLocal($local) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Collection
+ */
+ public function setAttributes($attributes) {}
+
+ /**
+ * Sets an array of filters in the collection
+ *
+ * @param array $filters
+ * @return Collection
+ */
+ public function setFilters($filters) {}
+
+ /**
+ * Sets the target local
+ *
+ * @param bool $targetLocal
+ * @return Collection
+ */
+ public function setTargetLocal($targetLocal) {}
+
+ /**
+ * Sets if all filtered resources in the collection must be joined in a single result file
+ *
+ * @param bool $join
+ * @return Collection
+ */
+ public function join($join) {}
+
+ /**
+ * Returns the complete location where the joined/filtered collection must be written
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealTargetPath($basePath) {}
+
+ /**
+ * Adds a filter to the collection
+ *
+ * @param mixed $filter
+ * @return Collection
+ */
+ public function addFilter(\Phalcon\Assets\FilterInterface $filter) {}
+
+
+<<<<<<< HEAD
+ function zephir_init_properties_Phalcon_Assets_Collection() {}
+=======
+ public function __construct() {}
+
+
+ function zephir_init_properties() {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/assets/Exception.php b/ide/2.0.4/Phalcon/assets/Exception.php
new file mode 100644
index 000000000..316b6e4a7
--- /dev/null
+++ b/ide/2.0.4/Phalcon/assets/Exception.php
@@ -0,0 +1,12 @@
+
+ * $inline = new \Phalcon\Assets\Inline('js', 'alert("hello world");');
+ *
+ */
+class Inline
+{
+
+ protected $_type;
+
+
+ protected $_content;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+
+ public function getType() {}
+
+
+ public function getContent() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+ /**
+ * Phalcon\Assets\Inline constructor
+ *
+ * @param string $type
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $content, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the inline's type
+ *
+ * @param string $type
+ * @return Inline
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Inline
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Inline
+ */
+ public function setAttributes($attributes) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/assets/Manager.php b/ide/2.0.4/Phalcon/assets/Manager.php
new file mode 100644
index 000000000..f1cddb9aa
--- /dev/null
+++ b/ide/2.0.4/Phalcon/assets/Manager.php
@@ -0,0 +1,268 @@
+
+ * $assets->addCss('css/bootstrap.css');
+ * $assets->addCss('http://bootstrap.my-cdn.com/style.css', false);
+ *
+ *
+ * @param string $path
+<<<<<<< HEAD
+ * @param mixed $local
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+=======
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addCss($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline Css to the 'css' collection
+ *
+ * @param string $content
+<<<<<<< HEAD
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+=======
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addInlineCss($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a javascript resource to the 'js' collection
+ *
+ * $assets->addJs('scripts/jquery.js');
+ * $assets->addJs('http://jquery.my-cdn.com/jquery.js', false);
+ *
+ *
+ * @param string $path
+<<<<<<< HEAD
+ * @param mixed $local
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+=======
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addJs($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline javascript to the 'js' collection
+ *
+ * @param string $content
+<<<<<<< HEAD
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+=======
+ * @param boolean $filter
+ * @param array $attributes
+ * @return \Phalcon\Assets\Manager
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addInlineJs($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a resource by its type
+ *
+ * $assets->addResourceByType('css', new \Phalcon\Assets\Resource\Css('css/style.css'));
+ *
+ *
+ * @param string $type
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResourceByType($type, \Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a inline code by its type
+ *
+ * @param string $type
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCodeByType($type, Inline $code) {}
+
+ /**
+ * Adds a raw resource to the manager
+ *
+ * $assets->addResource(new Phalcon\Assets\Resource('css', 'css/style.css'));
+ *
+ *
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResource(\Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a raw inline code to the manager
+ *
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCode(Inline $code) {}
+
+ /**
+ * Sets a collection in the Assets Manager
+ *
+ * $assets->set('js', $collection);
+ *
+ *
+ * @param string $id
+ * @param mixed $collection
+ * @return Manager
+ */
+ public function set($id, \Phalcon\Assets\Collection $collection) {}
+
+ /**
+ * Returns a collection by its id
+ *
+ * $scripts = $assets->get('js');
+ *
+ *
+ * @param string $id
+ * @return \Phalcon\Assets\Collection
+ */
+ public function get($id) {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getCss() {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getJs() {}
+
+ /**
+ * Creates/Returns a collection of resources
+ *
+ * @param string $name
+ * @return \Phalcon\Assets\Collection
+ */
+ public function collection($name) {}
+
+ /**
+ * Traverses a collection calling the callback to generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param callback $callback
+ * @param string $type
+ */
+ public function output(\Phalcon\Assets\Collection $collection, $callback, $type) {}
+
+ /**
+ * Traverses a collection and generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param string $type
+ */
+ public function outputInline(\Phalcon\Assets\Collection $collection, $type) {}
+
+ /**
+ * Prints the HTML for CSS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline CSS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for JS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputJs($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline JS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineJs($collectionName = null) {}
+
+ /**
+ * Returns existing collections in the manager
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getCollections() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/assets/Resource.php b/ide/2.0.4/Phalcon/assets/Resource.php
new file mode 100644
index 000000000..e2013640d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/assets/Resource.php
@@ -0,0 +1,170 @@
+
+ * $resource = new \Phalcon\Assets\Resource('js', 'javascripts/jquery.js');
+ *
+ */
+class Resource
+{
+
+ protected $_type;
+
+
+ protected $_path;
+
+
+ protected $_local;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+ protected $_sourcePath;
+
+
+ protected $_targetPath;
+
+
+ protected $_targetUri;
+
+
+
+ public function getType() {}
+
+
+ public function getPath() {}
+
+
+ public function getLocal() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+
+ public function getSourcePath() {}
+
+
+ public function getTargetPath() {}
+
+
+ public function getTargetUri() {}
+
+ /**
+ * Phalcon\Assets\Resource constructor
+ *
+ * @param string $type
+ * @param string $path
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the resource's type
+ *
+ * @param string $type
+ * @return Resource
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets the resource's path
+ *
+ * @param string $path
+ * @return Resource
+ */
+ public function setPath($path) {}
+
+ /**
+ * Sets if the resource is local or external
+ *
+ * @param bool $local
+ * @return Resource
+ */
+ public function setLocal($local) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Resource
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Resource
+ */
+ public function setAttributes($attributes) {}
+
+ /**
+ * Sets a target uri for the generated HTML
+ *
+ * @param string $targetUri
+ * @return Resource
+ */
+ public function setTargetUri($targetUri) {}
+
+ /**
+ * Sets the resource's source path
+ *
+ * @param string $sourcePath
+ * @return Resource
+ */
+ public function setSourcePath($sourcePath) {}
+
+ /**
+ * Sets the resource's target path
+ *
+ * @param string $targetPath
+ * @return Resource
+ */
+ public function setTargetPath($targetPath) {}
+
+ /**
+ * Returns the content of the resource as an string
+ * Optionally a base path where the resource is located can be set
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getContent($basePath = null) {}
+
+ /**
+ * Returns the real target uri for the generated HTML
+ *
+ * @return string
+ */
+ public function getRealTargetUri() {}
+
+ /**
+ * Returns the complete location where the resource is located
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealSourcePath($basePath = null) {}
+
+ /**
+ * Returns the complete location where the resource must be written
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealTargetPath($basePath = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/assets/filters/Cssmin.php b/ide/2.0.4/Phalcon/assets/filters/Cssmin.php
new file mode 100644
index 000000000..7071441f5
--- /dev/null
+++ b/ide/2.0.4/Phalcon/assets/filters/Cssmin.php
@@ -0,0 +1,22 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+class Css extends \Phalcon\Assets\Inline
+{
+
+ /**
+ * Phalcon\Assets\Inline\Css
+ *
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($content, $filter = true, $attributes = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/assets/inline/Js.php b/ide/2.0.4/Phalcon/assets/inline/Js.php
new file mode 100644
index 000000000..ab41d31ce
--- /dev/null
+++ b/ide/2.0.4/Phalcon/assets/inline/Js.php
@@ -0,0 +1,25 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+class Js extends \Phalcon\Assets\Inline
+{
+
+ /**
+ * Phalcon\Assets\Inline\Js
+ *
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($content, $filter = true, $attributes = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/assets/resource/Css.php b/ide/2.0.4/Phalcon/assets/resource/Css.php
new file mode 100644
index 000000000..6294e7b10
--- /dev/null
+++ b/ide/2.0.4/Phalcon/assets/resource/Css.php
@@ -0,0 +1,22 @@
+
+ * use Phalcon\Cache\Frontend\Data as DataFrontend,
+ * Phalcon\Cache\Multiple,
+ * Phalcon\Cache\Backend\Apc as ApcCache,
+ * Phalcon\Cache\Backend\Memcache as MemcacheCache,
+ * Phalcon\Cache\Backend\File as FileCache;
+ * $ultraFastFrontend = new DataFrontend(array(
+ * "lifetime" => 3600
+ * ));
+ * $fastFrontend = new DataFrontend(array(
+ * "lifetime" => 86400
+ * ));
+ * $slowFrontend = new DataFrontend(array(
+ * "lifetime" => 604800
+ * ));
+ * //Backends are registered from the fastest to the slower
+ * $cache = new Multiple(array(
+ * new ApcCache($ultraFastFrontend, array(
+ * "prefix" => 'cache',
+ * )),
+ * new MemcacheCache($fastFrontend, array(
+ * "prefix" => 'cache',
+ * "host" => "localhost",
+ * "port" => "11211"
+ * )),
+ * new FileCache($slowFrontend, array(
+ * "prefix" => 'cache',
+ * "cacheDir" => "../app/cache/"
+ * ))
+ * ));
+ * //Save, saves in every backend
+ * $cache->save('my-key', $data);
+ *
+ */
+class Multiple
+{
+
+ protected $_backends;
+
+
+ /**
+ * Phalcon\Cache\Multiple constructor
+ *
+ * @param Phalcon\Cache\BackendInterface[] backends
+ * @param mixed $backends
+ */
+ public function __construct($backends = null) {}
+
+ /**
+ * Adds a backend
+ *
+ * @param mixed $backend
+ * @return Multiple
+ */
+ public function push(\Phalcon\Cache\BackendInterface $backend) {}
+
+ /**
+ * Returns a cached content reading the internal backends
+ *
+ * @param mixed $keyName
+ * @param long $lifetime
+ * @param $string|int keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Starts every backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ */
+ public function start($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into all backends and stops the frontend
+ *
+ * @param string $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = null) {}
+
+ /**
+ * Deletes a value from each backend
+ *
+ * @param string|int $keyName
+ * @return boolean
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Checks if cache exists in at least one backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/cache/backend/Apc.php b/ide/2.0.4/Phalcon/cache/backend/Apc.php
new file mode 100644
index 000000000..8e6f53d83
--- /dev/null
+++ b/ide/2.0.4/Phalcon/cache/backend/Apc.php
@@ -0,0 +1,95 @@
+
+ * //Cache data for 2 days
+ * $frontCache = new \Phalcon\Cache\Frontend\Data(array(
+ * 'lifetime' => 172800
+ * ));
+ * $cache = new \Phalcon\Cache\Backend\Apc($frontCache, array(
+ * 'prefix' => 'app-data'
+ * ));
+ * //Cache arbitrary data
+ * $cache->save('my-data', array(1, 2, 3, 4, 5));
+ * //Get data
+ * $data = $cache->get('my-data');
+ *
+ */
+class Apc extends \Phalcon\Cache\Backend implements \Phalcon\Cache\BackendInterface
+{
+
+ /**
+ * Returns a cached content
+ *
+ * @param string $keyName
+ * @param long $lifetime
+ * @param $string|long keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into the APC backend and stops the frontend
+ *
+ * @param string|long $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = true) {}
+
+ /**
+ * Increment of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function increment($keyName = null, $value = 1) {}
+
+ /**
+ * Decrement of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function decrement($keyName = null, $value = 1) {}
+
+ /**
+ * Deletes a value from the cache by its key
+ *
+ * @param string $keyName
+ * @return bool
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Query the existing cached keys
+ *
+ * @param string $prefix
+ * @return array
+ */
+ public function queryKeys($prefix = null) {}
+
+ /**
+ * Checks if cache exists and it hasn't expired
+ *
+ * @param string|long $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+ /**
+ * Immediately invalidates all existing items.
+ *
+ * @return bool
+ */
+ public function flush() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/cache/backend/File.php b/ide/2.0.4/Phalcon/cache/backend/File.php
new file mode 100644
index 000000000..44e4a87c0
--- /dev/null
+++ b/ide/2.0.4/Phalcon/cache/backend/File.php
@@ -0,0 +1,135 @@
+
+ * //Cache the file for 2 days
+ * $frontendOptions = array(
+ * 'lifetime' => 172800
+ * );
+ * //Create a output cache
+ * $frontCache = \Phalcon\Cache\Frontend\Output($frontOptions);
+ * //Set the cache directory
+ * $backendOptions = array(
+ * 'cacheDir' => '../app/cache/'
+ * );
+ * //Create the File backend
+ * $cache = new \Phalcon\Cache\Backend\File($frontCache, $backendOptions);
+ * $content = $cache->start('my-cache');
+ * if ($content === null) {
+ * echo '
+ * application->addModules(array(
+ * 'admin' => array(
+ * 'className' => 'Multiple\Admin\Module',
+ * 'path' => '../apps/admin/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ */
+ public function addModules($modules) {}
+
+ /**
+ * Return the modules registered in the console
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Handle the whole command-line tasks
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Set an specific argument
+ *
+ * @param array $arguments
+ * @param bool $str
+ * @param bool $shift
+ * @return Console
+ */
+ public function setArgument($arguments = null, $str = true, $shift = true) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/cli/Dispatcher.php b/ide/2.0.4/Phalcon/cli/Dispatcher.php
new file mode 100644
index 000000000..9af6c4e3f
--- /dev/null
+++ b/ide/2.0.4/Phalcon/cli/Dispatcher.php
@@ -0,0 +1,111 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Cli\Dispatcher();
+ * $dispatcher->setDi(di);
+ * $dispatcher->setTaskName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $handle = dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher
+{
+
+ protected $_handlerSuffix = "Task";
+
+
+ protected $_defaultHandler = "main";
+
+
+ protected $_defaultAction = "main";
+
+
+ protected $_options;
+
+
+ /**
+ * Phalcon\Cli\Dispatcher constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the default task suffix
+ *
+ * @param string $taskSuffix
+ */
+ public function setTaskSuffix($taskSuffix) {}
+
+ /**
+ * Sets the default task name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the task name to be dispatched
+ *
+ * @param string $taskName
+ */
+ public function setTaskName($taskName) {}
+
+ /**
+ * Gets last dispatched task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getLastTask() {}
+
+ /**
+ * Returns the active task in the dispatcher
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getActiveTask() {}
+
+ /**
+ * Set the options to be dispatched
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get dispatched options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/cli/Router.php b/ide/2.0.4/Phalcon/cli/Router.php
new file mode 100644
index 000000000..57c6a3f88
--- /dev/null
+++ b/ide/2.0.4/Phalcon/cli/Router.php
@@ -0,0 +1,211 @@
+Phalcon\Cli\Router is the standard framework router. Routing is the
+ * process of taking a command-line arguments and
+ * decomposing it into parameters to determine which module, task, and
+ * action of that task should receive the request
+ *
+ * $router = new \Phalcon\Cli\Router();
+ * $router->handle(array(
+ * 'module' => 'main',
+ * 'task' => 'videos',
+ * 'action' => 'process'
+ * ));
+ * echo $router->getTaskName();
+ *
+ */
+class Router implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_module;
+
+
+ protected $_task;
+
+
+ protected $_action;
+
+
+ protected $_params;
+
+
+ protected $_defaultModule = null;
+
+
+ protected $_defaultTask = null;
+
+
+ protected $_defaultAction = null;
+
+
+ protected $_defaultParams;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ /**
+ * Phalcon\Cli\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return Router
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Handles routing information received from command-line arguments
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Adds a route to the router
+ *
+ * $router->add('/about', 'About::main');
+ *
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function add($pattern, $paths = null) {}
+
+ /**
+ * Returns proccesed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns proccesed task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Returns proccesed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns proccesed extra params
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param int $id
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Cli\Router\Route
+ */
+ public function getRouteByName($name) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/cli/Task.php b/ide/2.0.4/Phalcon/cli/Task.php
new file mode 100644
index 000000000..5a8d068e5
--- /dev/null
+++ b/ide/2.0.4/Phalcon/cli/Task.php
@@ -0,0 +1,31 @@
+
+ * class HelloTask extends \Phalcon\Cli\Task
+ * {
+ * //This action will be executed by default
+ * public function mainAction()
+ * {
+ * }
+ * public function findAction()
+ * {
+ * }
+ * }
+ *
+ */
+class Task extends \Phalcon\Di\Injectable
+{
+
+ /**
+ * Phalcon\Cli\Task constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/cli/console/Exception.php b/ide/2.0.4/Phalcon/cli/console/Exception.php
new file mode 100644
index 000000000..91718714c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/cli/console/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callback $callback
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return mixed
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param callable $converter
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+ /**
+ * Set the routing delimiter
+ *
+ * @param string $delimiter
+ */
+ public static function delimiter($delimiter = null) {}
+
+ /**
+ * Get routing delimiter
+ *
+ * @return string
+ */
+ public static function getDelimiter() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/config/Exception.php b/ide/2.0.4/Phalcon/config/Exception.php
new file mode 100644
index 000000000..a6f27ac66
--- /dev/null
+++ b/ide/2.0.4/Phalcon/config/Exception.php
@@ -0,0 +1,12 @@
+
+ * [database]
+ * adapter = Mysql
+ * host = localhost
+ * username = scott
+ * password = cheetah
+ * dbname = test_db
+ * [phalcon]
+ * controllersDir = "../app/controllers/"
+ * modelsDir = "../app/models/"
+ * viewsDir = "../app/views/"
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Ini("path/config.ini");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Ini extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Ini constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+ /**
+ * Build multidimensional array from string
+ *
+ * $this->_parseIniString('path.hello.world', 'value for last key');
+ * // result
+ * [
+ * 'path' => [
+ * 'hello' => [
+ * 'world' => 'value for last key',
+ * ],
+ * ],
+ * ];
+ *
+ *
+ * @param string $path
+ * @param mixed $value
+ * @return array
+ */
+ protected function _parseIniString($path, $value) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/config/adapter/Json.php b/ide/2.0.4/Phalcon/config/adapter/Json.php
new file mode 100644
index 000000000..5ee81e9f3
--- /dev/null
+++ b/ide/2.0.4/Phalcon/config/adapter/Json.php
@@ -0,0 +1,29 @@
+
+ * {"phalcon":{"baseuri":"\/phalcon\/"},"models":{"metadata":"memory"}}
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Json("path/config.json");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Json extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Json constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/config/adapter/Php.php b/ide/2.0.4/Phalcon/config/adapter/Php.php
new file mode 100644
index 000000000..b49ef21a8
--- /dev/null
+++ b/ide/2.0.4/Phalcon/config/adapter/Php.php
@@ -0,0 +1,46 @@
+
+ * array(
+ * 'adapter' => 'Mysql',
+ * 'host' => 'localhost',
+ * 'username' => 'scott',
+ * 'password' => 'cheetah',
+ * 'dbname' => 'test_db'
+ * ),
+<<<<<<< HEAD
+ * 'phalcon' => array(
+=======
+ * phalcon' => array(
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * 'controllersDir' => '../app/controllers/',
+ * 'modelsDir' => '../app/models/',
+ * 'viewsDir' => '../app/views/'
+ * ));
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Php("path/config.php");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Php extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Php constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/config/adapter/Yaml.php b/ide/2.0.4/Phalcon/config/adapter/Yaml.php
new file mode 100644
index 000000000..d9f5a9fe5
--- /dev/null
+++ b/ide/2.0.4/Phalcon/config/adapter/Yaml.php
@@ -0,0 +1,34 @@
+
+ * phalcon
+ * baseuri: /phalcon/
+ * models:
+ * metadata: memory
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Yaml("path/config.yaml");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Yaml extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Yaml constructor
+ *
+ * @throws \Phalcon\Config\Exception
+ * @param string $filePath
+ * @param array $callbacks
+ */
+ public function __construct($filePath, $callbacks = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/crypt/Exception.php b/ide/2.0.4/Phalcon/crypt/Exception.php
new file mode 100644
index 000000000..5af7d614f
--- /dev/null
+++ b/ide/2.0.4/Phalcon/crypt/Exception.php
@@ -0,0 +1,12 @@
+
+ * //Getting first robot
+ * $robot = $connection->fecthOne("SELECTFROM robots");
+ * print_r($robot);
+ * //Getting first robot with associative indexes only
+ * $robot = $connection->fecthOne("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $fetchMode
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return array
+ */
+<<<<<<< HEAD
+ public function fetchOne($sqlQuery, $fetchMode = Db::FETCH_ASSOC, $bindParams = null, $bindTypes = null) {}
+=======
+ public function fetchOne($sqlQuery, $fetchMode = Db::FETCH_BOTH, $bindParams = null, $bindTypes = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Dumps the complete result of a query into an array
+ *
+ * //Getting all robots with associative indexes only
+ * $robots = $connection->fetchAll("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * foreach ($robots as $robot) {
+ * print_r($robot);
+ * }
+ * //Getting all robots that contains word "robot" withing the name
+ * $robots = $connection->fetchAll("SELECTFROM robots WHERE name LIKE :name",
+ * Phalcon\Db::FETCH_ASSOC,
+ * array('name' => '%robot%')
+ * );
+ * foreach($robots as $robot){
+ * print_r($robot);
+ * }
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $fetchMode
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return array
+ */
+<<<<<<< HEAD
+ public function fetchAll($sqlQuery, $fetchMode = Db::FETCH_ASSOC, $bindParams = null, $bindTypes = null) {}
+=======
+ public function fetchAll($sqlQuery, $fetchMode = 2, $bindParams = null, $bindTypes = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Returns the n'th field of first row in a SQL query result
+ *
+ * //Getting count of robots
+ * $robotsCount = $connection->fetchColumn("SELECT count(*) FROM robots");
+ * print_r($robotsCount);
+ * //Getting name of last edited robot
+<<<<<<< HEAD
+ * $robot = $connection->fetchColumn("SELECT id, name FROM robots order by modified desc", 1);
+=======
+ * $robot = $connection->fetchColumn("SELECT id, name FROM robots order by modified desc");
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param array $placeholders
+ * @param int|string $column
+ * @return string|
+ */
+ public function fetchColumn($sqlQuery, $placeholders = null, $column = 0) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ *
+<<<<<<< HEAD
+ * // Inserting a new robot
+=======
+ * //Inserting a new robot
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+<<<<<<< HEAD
+ * // Next SQL sentence is sent to the database system
+=======
+ * //Next SQL sentence is sent to the database system
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param string|array $table
+ * @param array $values
+ * @param mixed $fields
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @return
+ */
+ public function insert($table, $values, $fields = null, $dataTypes = null) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+<<<<<<< HEAD
+ *
+ * //Inserting a new robot
+ * $success = $connection->insertAsDict(
+=======
+ * Another, more convenient syntax
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * "robots",
+ * array(
+ * "name" => "Astro Boy",
+ * "year" => 1952
+ * )
+ * );
+ * //Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $dataTypes
+ * @param $string table
+ * @param $array dataTypes
+ * @return
+ */
+ public function insertAsDict($table, $data, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ * //Updating existing robot with array condition and $dataTypes
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * array(
+ * 'conditions' => "id = ?",
+ * 'bind' => array($some_unsafe_id),
+ * 'bindTypes' => array(PDO::PARAM_INT) //use only if you use $dataTypes param
+ * ),
+ * array(PDO::PARAM_STR)
+ * );
+ *
+ * Warning! If $whereCondition is string it not escaped.
+ *
+ * @param string|array $table
+ * @param mixed $fields
+ * @param mixed $values
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @param $string|array whereCondition
+ * @return
+ */
+ public function update($table, $fields, $values, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ * Another, more convenient syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array(
+ * "name" => "New Astro Boy"
+ * ),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $string whereCondition
+ * @param $array dataTypes
+ * @return
+ */
+ public function updateAsDict($table, $data, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Deletes data from a table using custom RBDM SQL syntax
+ *
+ * //Deleting existing robot
+ * $success = $connection->delete(
+ * "robots",
+ * "id = 101"
+ * );
+ * //Next SQL sentence is generated
+ * DELETE FROM `robots` WHERE `id` = 101
+ *
+ *
+ * @param string|array $table
+ * @param string $whereCondition
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return boolean
+ */
+ public function delete($table, $whereCondition = null, $placeholders = null, $dataTypes = null) {}
+
+ /**
+ * Gets a list of columns
+ *
+ * @param array columnList
+ * @return string
+ * @param mixed $columnList
+ * @return string
+ */
+ public function getColumnList($columnList) {}
+
+ /**
+ * Appends a LIMIT clause to $sqlQuery argument
+ *
+ * echo $connection->limit("SELECTFROM robots", 5);
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.table
+ *
+ * var_dump($connection->tableExists("blog", "posts"));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * var_dump($connection->viewExists("active_users", "posts"));
+ *
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Drops a table from a schema/database
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropTable($tableName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Creates a view
+ *
+ * @param string tableName
+ * @param array definition
+ * @param string schemaName
+ * @return boolean
+ * @param string $viewName
+ * @param array $definition
+ * @param mixed $schemaName
+ * @return bool
+ */
+ public function createView($viewName, $definition, $schemaName = null) {}
+
+ /**
+ * Drops a view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropView($viewName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Adds a column to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @return bool
+ */
+ public function addColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Drops a column from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $columnName
+ * @return bool
+ */
+ public function dropColumn($tableName, $schemaName, $columnName) {}
+
+ /**
+ * Adds an index to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addIndex($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drop an index from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $indexName
+ * @return bool
+ */
+ public function dropIndex($tableName, $schemaName, $indexName) {}
+
+ /**
+ * Adds a primary key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addPrimaryKey($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drops a table's primary key
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function dropPrimaryKey($tableName, $schemaName) {}
+
+ /**
+ * Adds a foreign key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $reference
+ * @return bool
+ */
+ public function addForeignKey($tableName, $schemaName, ReferenceInterface $reference) {}
+
+ /**
+ * Drops a foreign key from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $referenceName
+ * @return bool
+ */
+ public function dropForeignKey($tableName, $schemaName, $referenceName) {}
+
+ /**
+ * Returns the SQL column definition from a column
+ *
+ * @param mixed $column
+ * @return string
+ */
+ public function getColumnDefinition(\Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * List all tables on a database
+ *
+ * print_r($connection->listTables("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * List all views on a database
+ *
+ * print_r($connection->listViews("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * print_r($connection->describeIndexes('robots_parts'));
+ *
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\Index[]
+ * @param string $table
+ * @param mixed $schema
+ * @return Index
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * print_r($connection->describeReferences('robots_parts'));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return Reference
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Gets creation options from a table
+ *
+ * print_r($connection->tableOptions('robots'));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return array
+ */
+ public function tableOptions($tableName, $schemaName = null) {}
+
+ /**
+ * Creates a new savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Releases given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Rollbacks given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Set if nested transactions should use savepoints
+ *
+ * @param bool $nestedTransactionsWithSavepoints
+ * @return AdapterInterface
+ */
+ public function setNestedTransactionsWithSavepoints($nestedTransactionsWithSavepoints) {}
+
+ /**
+ * Returns if nested transactions should use savepoints
+ *
+ * @return bool
+ */
+ public function isNestedTransactionsWithSavepoints() {}
+
+ /**
+ * Returns the savepoint name to use for nested transactions
+ *
+ * @return string
+ */
+ public function getNestedTransactionSavepointName() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+<<<<<<< HEAD
+ * Returns the default value to make the RBDM use the default value declared in the table definition
+ *
+ * //Inserting a new robot with a valid default value for the column 'year'
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", $connection->getDefaultValue()),
+ * array("name", "year")
+ * );
+ *
+ *
+ * @return RawValue
+ */
+ public function getDefaultValue() {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return descriptor used to connect to the active database
+ *
+ * @return array
+ */
+ public function getDescriptor() {}
+
+ /**
+ * Gets the active connection unique identifier
+ *
+ * @return string
+ */
+ public function getConnectionId() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return string
+ */
+ public function getSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object without replace bound paramters
+ *
+ * @return string
+ */
+ public function getRealSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return array
+ */
+ public function getSQLBindTypes() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/AdapterInterface.php b/ide/2.0.4/Phalcon/db/AdapterInterface.php
new file mode 100644
index 000000000..7726f24de
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/AdapterInterface.php
@@ -0,0 +1,559 @@
+
+ * use Phalcon\Db\Column as Column;
+ * //column definition
+ * $column = new Column("id", array(
+ * "type" => Column::TYPE_INTEGER,
+ * "size" => 10,
+ * "unsigned" => true,
+ * "notNull" => true,
+ * "autoIncrement" => true,
+ * "first" => true
+ * ));
+ * //add column to existing table
+ * $connection->addColumn("robots", null, $column);
+ *
+ */
+class Column implements \Phalcon\Db\ColumnInterface
+{
+ /**
+ * Integer abstract type
+ */
+ const TYPE_INTEGER = 0;
+
+ /**
+ * Date abstract type
+ */
+ const TYPE_DATE = 1;
+
+ /**
+ * Varchar abstract type
+ */
+ const TYPE_VARCHAR = 2;
+
+ /**
+ * Decimal abstract type
+ */
+ const TYPE_DECIMAL = 3;
+
+ /**
+ * Datetime abstract type
+ */
+ const TYPE_DATETIME = 4;
+
+ /**
+ * Char abstract type
+ */
+ const TYPE_CHAR = 5;
+
+ /**
+ * Text abstract data type
+ */
+ const TYPE_TEXT = 6;
+
+ /**
+ * Float abstract data type
+ */
+ const TYPE_FLOAT = 7;
+
+ /**
+ * Boolean abstract data type
+ */
+ const TYPE_BOOLEAN = 8;
+
+ /**
+ * Double abstract data type
+ */
+ const TYPE_DOUBLE = 9;
+
+ /**
+ * Tinyblob abstract data type
+ */
+ const TYPE_TINYBLOB = 10;
+
+ /**
+ * Blob abstract data type
+ */
+ const TYPE_BLOB = 11;
+
+ /**
+ * Mediumblob abstract data type
+ */
+ const TYPE_MEDIUMBLOB = 12;
+
+ /**
+ * Longblob abstract data type
+ */
+ const TYPE_LONGBLOB = 13;
+
+<<<<<<< HEAD
+ /**
+ * Big integer abstract type
+ */
+ const TYPE_BIGINTEGER = 14;
+
+ /**
+ * Json abstract type
+ */
+ const TYPE_JSON = 15;
+
+ /**
+ * Jsonb abstract type
+ */
+ const TYPE_JSONB = 16;
+=======
+ /**
+ * Longblob abstract data type
+ */
+ const TYPE_JSON = 14;
+
+ /**
+ * Longblob abstract data type
+ */
+ const TYPE_JSONB = 15;
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Bind Type Null
+ */
+ const BIND_PARAM_NULL = 0;
+
+ /**
+ * Bind Type Integer
+ */
+ const BIND_PARAM_INT = 1;
+
+ /**
+ * Bind Type String
+ */
+ const BIND_PARAM_STR = 2;
+
+ /**
+<<<<<<< HEAD
+ * Bind Type Blob
+ */
+ const BIND_PARAM_BLOB = 3;
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Bind Type Bool
+ */
+ const BIND_PARAM_BOOL = 5;
+
+ /**
+ * Bind Type Decimal
+ */
+ const BIND_PARAM_DECIMAL = 32;
+
+ /**
+ * Skip binding by type
+ */
+ const BIND_SKIP = 1024;
+
+ /**
+ * Column's name
+ *
+ * @var string
+ */
+ protected $_name;
+
+ /**
+ * Schema which table related is
+ *
+ * @var string
+ */
+ protected $_schemaName;
+
+ /**
+ * Column data type
+ *
+ * @var int|string
+ */
+ protected $_type;
+
+ /**
+ * Column data type reference
+ *
+ * @var int
+ */
+ protected $_typeReference;
+
+ /**
+ * Column data type values
+ *
+ * @var array|string
+ */
+ protected $_typeValues;
+
+ /**
+ * The column have some numeric type?
+ */
+ protected $_isNumeric = false;
+
+ /**
+ * Integer column size
+ *
+ * @var int
+ */
+ protected $_size = 0;
+
+ /**
+ * Integer column number scale
+ *
+ * @var int
+ */
+ protected $_scale = 0;
+
+ /**
+ * Default column value
+ */
+ protected $_default = null;
+
+ /**
+ * Integer column unsigned?
+ *
+ * @var boolean
+ */
+ protected $_unsigned = false;
+
+ /**
+ * Column not nullable?
+ *
+ * @var boolean
+ */
+ protected $_notNull = false;
+
+ /**
+ * Column is part of the primary key?
+ */
+ protected $_primary = false;
+
+ /**
+ * Column is autoIncrement?
+ *
+ * @var boolean
+ */
+ protected $_autoIncrement = false;
+
+ /**
+ * Position is first
+ *
+ * @var boolean
+ */
+ protected $_first = false;
+
+ /**
+ * Column Position
+ *
+ * @var string
+ */
+ protected $_after;
+
+ /**
+ * Bind Type
+ */
+ protected $_bindType = 2;
+
+
+ /**
+ * Column's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Schema which table related is
+ *
+ * @return string
+ */
+ public function getSchemaName() {}
+
+ /**
+ * Column data type
+ *
+ * @return int|string
+ */
+ public function getType() {}
+
+ /**
+ * Column data type reference
+ *
+ * @return int
+ */
+ public function getTypeReference() {}
+
+ /**
+ * Column data type values
+ *
+ * @return array|string
+ */
+ public function getTypeValues() {}
+
+ /**
+ * Integer column size
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Integer column number scale
+ *
+ * @return int
+ */
+ public function getScale() {}
+
+ /**
+ * Default column value
+ */
+ public function getDefault() {}
+
+ /**
+ * Phalcon\Db\Column constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Returns true if number column is unsigned
+ *
+ * @return bool
+ */
+ public function isUnsigned() {}
+
+ /**
+ * Not null
+ *
+ * @return bool
+ */
+ public function isNotNull() {}
+
+ /**
+ * Column is part of the primary key?
+ *
+ * @return bool
+ */
+ public function isPrimary() {}
+
+ /**
+ * Auto-Increment
+ *
+ * @return bool
+ */
+ public function isAutoIncrement() {}
+
+ /**
+ * Check whether column have an numeric type
+ *
+ * @return bool
+ */
+ public function isNumeric() {}
+
+ /**
+ * Check whether column have first position in table
+ *
+ * @return bool
+ */
+ public function isFirst() {}
+
+ /**
+ * Check whether field absolute to position in table
+ *
+ * @return string
+ */
+ public function getAfterPosition() {}
+
+ /**
+ * Returns the type of bind handling
+ *
+ * @return int
+ */
+ public function getBindType() {}
+
+ /**
+ * Restores the internal state of a Phalcon\Db\Column object
+ *
+ * @param array $data
+ * @return Column
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/ColumnInterface.php b/ide/2.0.4/Phalcon/db/ColumnInterface.php
new file mode 100644
index 000000000..658903aaf
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/ColumnInterface.php
@@ -0,0 +1,140 @@
+
+ * $sql = $dialect->limit('SELECTFROM robots', 10);
+ * echo $sql; // SELECTFROM robots LIMIT 10
+ * $sql = $dialect->limit('SELECTFROM robots', [10, 50]);
+ * echo $sql; // SELECTFROM robots LIMIT 10 OFFSET 50
+ *
+ *
+ * @param string $sqlQuery
+ * @param mixed $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * $sql = $dialect->forUpdate('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots FOR UPDATE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * $sql = $dialect->sharedLock('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots LOCK IN SHARE MODE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Gets a list of columns with escaped identifiers
+ *
+ * echo $dialect->getColumnList(array('column1', 'column'));
+ *
+ *
+ * @param array $columnList
+ * @return string
+ */
+ public final function getColumnList($columnList) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param mixed $column
+ * @return string
+ */
+ public final function getSqlColumn($column) {}
+
+ /**
+ * Transforms an intermediate representation for a expression into a database system valid expression
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ public function getSqlExpression($expression, $escapeChar = null) {}
+
+ /**
+ * Transform an intermediate representation of a schema/table into a database system valid expression
+ *
+ * @param mixed $table
+ * @param string $escapeChar
+ * @return string
+ */
+ public final function getSqlTable($table, $escapeChar = null) {}
+
+ /**
+ * Builds a SELECT statement
+ *
+ * @param array $definition
+ * @return string
+ */
+ public function select($definition) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+ /**
+ * Generate SQL to create a new savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Generate SQL to release a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Generate SQL to rollback a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionScalar($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve object expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionObject($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve qualified expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionQualified($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve binary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionBinaryOperations($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve unary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionUnaryOperations($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve function calls
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionFunctionCall($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve Lists
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionList($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionAll($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CAST of values
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionCastValue($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CONVERT of values encodings
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionConvertValue($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CASE expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionCase($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a FROM clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionFrom($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a JOINs clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionJoins($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a WHERE clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionWhere($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a GROUP BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionGroupBy($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a HAVING clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionHaving($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a ORDER BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionOrderBy($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a LIMIT clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionLimit($expression, $escapeChar = null) {}
+
+ /**
+ * Prepares column for this RDBMS
+ *
+ * @param string $qualified
+ * @param string $alias
+ * @return string
+ */
+ protected function prepareColumnAlias($qualified, $alias = null) {}
+
+ /**
+ * Prepares table for this RDBMS
+ *
+ * @param string $table
+ * @param string $schema
+ * @param string $alias
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareTable($table, $schema = null, $alias = null, $escapeChar = null) {}
+
+ /**
+ * Prepares qualified for this RDBMS
+ *
+ * @param string $column
+ * @param string $domain
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareQualified($column, $domain = null, $escapeChar = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/DialectInterface.php b/ide/2.0.4/Phalcon/db/DialectInterface.php
new file mode 100644
index 000000000..a1deb6019
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/DialectInterface.php
@@ -0,0 +1,290 @@
+
+ * $profiler = new \Phalcon\Db\Profiler();
+ * //Set the connection profiler
+ * $connection->setProfiler($profiler);
+ * $sql = "SELECT buyer_name, quantity, product_name
+ * FROM buyers LEFT JOIN products ON
+ * buyers.pid=products.id";
+ * //Execute a SQL statement
+ * $connection->query($sql);
+ * //Get the last profile in the profiler
+ * $profile = $profiler->getLastProfile();
+ * echo "SQL Statement: ", $profile->getSQLStatement(), "\n";
+ * echo "Start Time: ", $profile->getInitialTime(), "\n";
+ * echo "Final Time: ", $profile->getFinalTime(), "\n";
+ * echo "Total Elapsed Time: ", $profile->getTotalElapsedSeconds(), "\n";
+ *
+ */
+class Profiler
+{
+ /**
+ * All the Phalcon\Db\Profiler\Item in the active profile
+ *
+ * @var array
+ */
+ protected $_allProfiles;
+
+ /**
+ * Active Phalcon\Db\Profiler\Item
+ *
+ * @var Phalcon\Db\Profiler\Item
+ */
+ protected $_activeProfile;
+
+ /**
+ * Total time spent by all profiles to complete
+ *
+ * @var float
+ */
+ protected $_totalSeconds = 0;
+
+
+ /**
+ * Starts the profile of a SQL sentence
+ *
+ * @param string $sqlStatement
+ * @param mixed $sqlVariables
+ * @param mixed $sqlBindTypes
+ * @return \Phalcon\Db\Profiler
+ */
+ public function startProfile($sqlStatement, $sqlVariables = null, $sqlBindTypes = null) {}
+
+ /**
+ * Stops the active profile
+ *
+ * @return Profiler
+ */
+ public function stopProfile() {}
+
+ /**
+ * Returns the total number of SQL statements processed
+ *
+ * @return int
+ */
+ public function getNumberTotalStatements() {}
+
+ /**
+ * Returns the total time in seconds spent by the profiles
+ *
+ * @return double
+ */
+ public function getTotalElapsedSeconds() {}
+
+ /**
+ * Returns all the processed profiles
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getProfiles() {}
+
+ /**
+ * Resets the profiler, cleaning up all the profiles
+ *
+ * @return Profiler
+ */
+ public function reset() {}
+
+ /**
+ * Returns the last profile executed in the profiler
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getLastProfile() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/RawValue.php b/ide/2.0.4/Phalcon/db/RawValue.php
new file mode 100644
index 000000000..ad50e9f50
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/RawValue.php
@@ -0,0 +1,49 @@
+
+ * $subscriber = new Subscribers();
+ * $subscriber->email = 'andres@phalconphp.com';
+ * $subscriber->createdAt = new \Phalcon\Db\RawValue('now()');
+ * $subscriber->save();
+ *
+ */
+class RawValue
+{
+ /**
+ * Raw value without quoting or formating
+ *
+ * @var string
+ */
+ protected $_value;
+
+
+ /**
+ * Raw value without quoting or formating
+ *
+ * @return string
+ */
+ public function getValue() {}
+
+ /**
+ * Raw value without quoting or formating
+ */
+ public function __toString() {}
+
+ /**
+ * Phalcon\Db\RawValue constructor
+ *
+<<<<<<< HEAD
+ * @param mixed $value
+=======
+ * @param string $value
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function __construct($value) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/Reference.php b/ide/2.0.4/Phalcon/db/Reference.php
new file mode 100644
index 000000000..ad0ca1f80
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/Reference.php
@@ -0,0 +1,132 @@
+
+ * $reference = new \Phalcon\Db\Reference("field_fk", array(
+ * 'referencedSchema' => "invoicing",
+ * 'referencedTable' => "products",
+ * 'columns' => array("product_type", "product_code"),
+ * 'referencedColumns' => array("type", "code")
+ * ));
+ *
+ */
+class Reference implements \Phalcon\Db\ReferenceInterface
+{
+ /**
+ * Constraint name
+ *
+ * @var string
+ */
+ protected $_name;
+
+
+ protected $_schemaName;
+
+
+ protected $_referencedSchema;
+
+ /**
+ * Referenced Table
+ *
+ * @var string
+ */
+ protected $_referencedTable;
+
+ /**
+ * Local reference columns
+ *
+ * @var array
+ */
+ protected $_columns;
+
+ /**
+ * Referenced Columns
+ *
+ * @var array
+ */
+ protected $_referencedColumns;
+
+ /**
+ * ON DELETE
+ *
+ * @var array
+ */
+ protected $_onDelete;
+
+ /**
+ * ON UPDATE
+ *
+ * @var array
+ */
+ protected $_onUpdate;
+
+
+ /**
+ * Constraint name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+
+ public function getSchemaName() {}
+
+
+ public function getReferencedSchema() {}
+
+ /**
+ * Referenced Table
+ *
+ * @return string
+ */
+ public function getReferencedTable() {}
+
+ /**
+ * Local reference columns
+ *
+ * @return array
+ */
+ public function getColumns() {}
+
+ /**
+ * Referenced Columns
+ *
+ * @return array
+ */
+ public function getReferencedColumns() {}
+
+ /**
+ * ON DELETE
+ *
+ * @return array
+ */
+ public function getOnDelete() {}
+
+ /**
+ * ON UPDATE
+ *
+ * @return array
+ */
+ public function getOnUpdate() {}
+
+ /**
+ * Phalcon\Db\Reference constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Restore a Phalcon\Db\Reference object from export
+ *
+ * @param array $data
+ * @return Reference
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/ReferenceInterface.php b/ide/2.0.4/Phalcon/db/ReferenceInterface.php
new file mode 100644
index 000000000..89e52781f
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/ReferenceInterface.php
@@ -0,0 +1,84 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function setFetchMode($fetchMode);
+
+ /**
+ * Gets the internal PDO result object
+ *
+ * @return \PDOStatement
+ */
+ public function getInternalResult();
+
+}
diff --git a/ide/2.0.4/Phalcon/db/adapter/Pdo.php b/ide/2.0.4/Phalcon/db/adapter/Pdo.php
new file mode 100644
index 000000000..48eb58dbd
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/adapter/Pdo.php
@@ -0,0 +1,245 @@
+
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306'
+ * ));
+ *
+ */
+abstract class Pdo extends \Phalcon\Db\Adapter
+{
+ /**
+ * PDO Handler
+ */
+ protected $_pdo;
+
+ /**
+ * Last affected rows
+ */
+ protected $_affectedRows;
+
+
+ /**
+ * Constructor for Phalcon\Db\Adapter\Pdo
+ *
+ * @param array $descriptor
+ */
+ public function __construct($descriptor) {}
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection
+ *
+ * //Make a connection
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * ));
+ * //Reconnect
+ * $connection->connect();
+ *
+ *
+ * @param mixed $descriptor
+ * @param $array descriptor
+ * @return
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns a PDO prepared statement to be executed with 'executePrepared'
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param string $sqlStatement
+ * @return \PDOStatement
+ */
+ public function prepare($sqlStatement) {}
+
+ /**
+ * Executes a prepared statement binding. This function uses integer indexes starting from zero
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param \PDOStatement $statement
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return \PDOStatement
+ */
+ public function executePrepared(\PDOStatement $statement, $placeholders, $dataTypes) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server is returning rows
+ *
+ * //Querying data
+ * $resultset = $connection->query("SELECTFROM robots WHERE type='mechanical'");
+ * $resultset = $connection->query("SELECTFROM robots WHERE type=?", array("mechanical"));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool|\Phalcon\Db\ResultInterface
+ */
+ public function query($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server doesn't return any rows
+ *
+ * //Inserting data
+ * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
+ * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool
+ */
+ public function execute($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Returns the number of affected rows by the lastest INSERT/UPDATE/DELETE executed in the database system
+ *
+ * $connection->execute("DELETE FROM robots");
+ * echo $connection->affectedRows(), ' were deleted';
+ *
+ *
+ * @return int
+ */
+ public function affectedRows() {}
+
+ /**
+ * Closes the active connection returning success. Phalcon automatically closes and destroys
+ * active connections when the request ends
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * $escapedTable = $connection->escapeIdentifier('robots');
+ * $escapedTable = $connection->escapeIdentifier(array('store', 'robots'));
+ *
+ *
+ * @param string $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Escapes a value to avoid SQL injections according to the active charset in the connection
+ *
+ * $escapedStr = $connection->escapeString('some dangerous value');
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public function escapeString($str) {}
+
+ /**
+ * Converts bound parameters such as :name: or ?1 into PDO bind params ?
+ *
+ * print_r($connection->convertBoundParams('SELECTFROM robots WHERE name = :name:', array('Bender')));
+ *
+ *
+ * @param string $sql
+ * @param array $params
+ * @return array
+ */
+ public function convertBoundParams($sql, $params = array()) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int|boolean
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Starts a transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function begin($nesting = true) {}
+
+ /**
+ * Rollbacks the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function rollback($nesting = true) {}
+
+ /**
+ * Commits the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function commit($nesting = true) {}
+
+ /**
+ * Returns the current transaction nesting level
+ *
+ * @return int
+ */
+ public function getTransactionLevel() {}
+
+ /**
+ * Checks whether the connection is under a transaction
+ *
+ * $connection->begin();
+ * var_dump($connection->isUnderTransaction()); //true
+ *
+ *
+ * @return bool
+ */
+ public function isUnderTransaction() {}
+
+ /**
+ * Return internal PDO handler
+ *
+ * @return \Pdo
+ */
+ public function getInternalHandler() {}
+
+ /**
+ * Return the error info, if any
+ *
+ * @return array
+ */
+ public function getErrorInfo() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/adapter/pdo/Mysql.php b/ide/2.0.4/Phalcon/db/adapter/pdo/Mysql.php
new file mode 100644
index 000000000..dec124c0e
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/adapter/pdo/Mysql.php
@@ -0,0 +1,48 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "port" => 3306,
+ * "username" => "sigma",
+ * "password" => "secret"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql($config);
+ *
+ */
+class Mysql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "mysql";
+
+
+ protected $_dialectType = "mysql";
+
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * @param string|array $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/adapter/pdo/Oracle.php b/ide/2.0.4/Phalcon/db/adapter/pdo/Oracle.php
new file mode 100644
index 000000000..9e45aea25
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/adapter/pdo/Oracle.php
@@ -0,0 +1,84 @@
+
+ * $config = array(
+ * "dbname" => "//localhost/dbname",
+ * "username" => "oracle",
+ * "password" => "oracle"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Oracle($config);
+ *
+ */
+class Oracle extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "oci";
+
+
+ protected $_dialectType = "oracle";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param array $descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ * print_r($connection->describeColumns("posts")); ?>
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return the default identity value to insert in an identity column
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/adapter/pdo/Postgresql.php b/ide/2.0.4/Phalcon/db/adapter/pdo/Postgresql.php
new file mode 100644
index 000000000..301ae233c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/adapter/pdo/Postgresql.php
@@ -0,0 +1,99 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "username" => "postgres",
+ * "password" => ""
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Postgresql($config);
+ *
+ */
+class Postgresql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "pgsql";
+
+
+ protected $_dialectType = "postgresql";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/adapter/pdo/Sqlite.php b/ide/2.0.4/Phalcon/db/adapter/pdo/Sqlite.php
new file mode 100644
index 000000000..e3f4daacc
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/adapter/pdo/Sqlite.php
@@ -0,0 +1,95 @@
+
+ * $config = array(
+ * "dbname" => "/tmp/test.sqlite"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Sqlite($config);
+ *
+ */
+class Sqlite extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "sqlite";
+
+
+ protected $_dialectType = "sqlite";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\IndexInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\IndexInterface
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\ReferenceInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\ReferenceInterface
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+<<<<<<< HEAD
+ /**
+ * Returns the default value to make the RBDM use the default value declared in the table definition
+ *
+ * //Inserting a new robot with a valid default value for the column 'year'
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", $connection->getDefaultValue()),
+ * array("name", "year")
+ * );
+ *
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultValue() {}
+
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/db/dialect/MySQL.php b/ide/2.0.4/Phalcon/db/dialect/MySQL.php
new file mode 100644
index 000000000..6e8af8d16
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/dialect/MySQL.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Generates SQL to add the table creation options
+ *
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/dialect/Oracle.php b/ide/2.0.4/Phalcon/db/dialect/Oracle.php
new file mode 100644
index 000000000..972fdf46e
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/dialect/Oracle.php
@@ -0,0 +1,257 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/dialect/Postgresql.php b/ide/2.0.4/Phalcon/db/dialect/Postgresql.php
new file mode 100644
index 000000000..0a3b9f37e
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/dialect/Postgresql.php
@@ -0,0 +1,239 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/dialect/Sqlite.php b/ide/2.0.4/Phalcon/db/dialect/Sqlite.php
new file mode 100644
index 000000000..c606ad0c5
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/dialect/Sqlite.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query indexes detail on a table
+ *
+ * @param string $index
+ * @return string
+ */
+ public function describeIndex($index) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/db/profiler/Item.php b/ide/2.0.4/Phalcon/db/profiler/Item.php
new file mode 100644
index 000000000..79ad83855
--- /dev/null
+++ b/ide/2.0.4/Phalcon/db/profiler/Item.php
@@ -0,0 +1,124 @@
+
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ */
+class Pdo implements \Phalcon\Db\ResultInterface
+{
+
+ protected $_connection;
+
+
+ protected $_result;
+
+ /**
+ * Active fetch mode
+ */
+ protected $_fetchMode = Db::FETCH_OBJ;
+
+ /**
+ * Internal resultset
+ *
+ * @var \PDOStatement
+ */
+ protected $_pdoStatement;
+
+
+ protected $_sqlStatement;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_rowCount = false;
+
+
+ /**
+ * Phalcon\Db\Result\Pdo constructor
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \PDOStatement $result
+ * @param string $sqlStatement
+ * @param array $bindParams
+ * @param array $bindTypes
+ */
+ public function __construct(Db\AdapterInterface $connection, \PDOStatement $result, $sqlStatement = null, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Allows to execute the statement again. Some database systems don't support scrollable cursors,
+ * So, as cursors are forward only, we need to execute the cursor again to fetch rows from the begining
+ *
+ * @return bool
+ */
+ public function execute() {}
+
+ /**
+ * Fetches an array/object of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ * while ($robot = $result->fetch()) {
+<<<<<<< HEAD
+ * echo $robot->name;
+ * }
+ *
+ *
+ * @param mixed $fetchStyle
+ * @param mixed $cursorOrientation
+ * @param mixed $cursorOffset
+ */
+ public function fetch($fetchStyle = null, $cursorOrientation = null, $cursorOffset = null) {}
+=======
+ * echo robot->name;
+ * }
+ *
+ *
+ * @return mixed
+ */
+ public function fetch() {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Returns an array of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+<<<<<<< HEAD
+=======
+ *
+ * @return mixed
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function fetchArray() {}
+
+ /**
+ * Returns an array of arrays containing all the records in the result
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $robots = $result->fetchAll();
+ *
+ *
+<<<<<<< HEAD
+ * @param mixed $fetchStyle
+ * @param mixed $fetchArgument
+ * @param mixed $ctorArgs
+ * @return array
+ */
+ public function fetchAll($fetchStyle = null, $fetchArgument = null, $ctorArgs = null) {}
+=======
+ * @return array
+ */
+ public function fetchAll() {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Gets number of rows returned by a resultset
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * echo 'There are ', $result->numRows(), ' rows in the resultset';
+ *
+ *
+ * @return int
+ */
+ public function numRows() {}
+
+ /**
+ * Moves internal resultset cursor to another position letting us to fetch a certain row
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->dataSeek(2); // Move to third row on result
+ * $row = $result->fetch(); // Fetch third row
+ *
+ *
+ * @param long $number
+ */
+ public function dataSeek($number) {}
+
+ /**
+ * Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch()
+ *
+ * //Return array with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * //Return associative array without integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_ASSOC);
+ * //Return associative array together with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_BOTH);
+ * //Return an object
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ *
+ *
+ * @param int $fetchMode
+<<<<<<< HEAD
+ * @param mixed $colNoOrClassNameOrObject
+ * @param mixed $ctorargs
+ * @return bool
+ */
+ public function setFetchMode($fetchMode, $colNoOrClassNameOrObject = null, $ctorargs = null) {}
+=======
+ */
+ public function setFetchMode($fetchMode) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Gets the internal PDO result object
+ *
+ * @return \PDOStatement
+ */
+ public function getInternalResult() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/debug/Dump.php b/ide/2.0.4/Phalcon/debug/Dump.php
new file mode 100644
index 000000000..71c21c1cc
--- /dev/null
+++ b/ide/2.0.4/Phalcon/debug/Dump.php
@@ -0,0 +1,137 @@
+
+ * $foo = 123;
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ */
+class Dump
+{
+
+ protected $_detailed = false;
+
+
+ protected $_methods = null;
+
+
+ protected $_styles;
+
+
+
+ public function getDetailed() {}
+
+ /**
+ * @param mixed $detailed
+ */
+ public function setDetailed($detailed) {}
+
+ /**
+ * Phalcon\Debug\Dump constructor
+ *
+ * @param array $styles
+ * @param boolean $detailed debug object's private and protected properties
+ */
+ public function __construct($styles = null, $detailed = false) {}
+
+ /**
+ * Alias of variables() method
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function all() {}
+
+ /**
+ * Get style for type
+ *
+ * @param string $type
+ * @return string
+ */
+ protected function getStyle($type) {}
+
+ /**
+ * Set styles for vars type
+ *
+ * @param mixed $styles
+ * @return array
+ */
+ public function setStyles($styles = null) {}
+
+ /**
+ * Alias of variable() method
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function one($variable, $name = null) {}
+
+ /**
+ * Prepare an HTML string of information about a single variable.
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @param int $tab
+ * @return string
+ */
+ protected function output($variable, $name = null, $tab = 1) {}
+
+ /**
+ * Returns an HTML string of information about a single variable.
+ *
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function variable($variable, $name = null) {}
+
+ /**
+ * Returns an HTML string of debugging information about any number of
+ * variables, each wrapped in a "pre" tag.
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function variables() {}
+
+<<<<<<< HEAD
+ /**
+ * Returns an JSON string of information about a single variable.
+ *
+ * $foo = ["key" => "value"];
+ * echo (new \Phalcon\Debug\Dump())->toJson($foo);
+ * $foo = new stdClass();
+ * $foo->bar = 'buz';
+ * echo (new \Phalcon\Debug\Dump())->toJson($foo);
+ *
+ *
+ * @param mixed $variable
+ * @return string
+ */
+ public function toJson($variable) {}
+
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/debug/Exception.php b/ide/2.0.4/Phalcon/debug/Exception.php
new file mode 100644
index 000000000..12c2c2b76
--- /dev/null
+++ b/ide/2.0.4/Phalcon/debug/Exception.php
@@ -0,0 +1,12 @@
+
+ * $service = new \Phalcon\Di\Service('request', 'Phalcon\Http\Request');
+ * $request = service->resolve();
+ *
+ */
+class Service implements \Phalcon\Di\ServiceInterface
+{
+
+ protected $_name;
+
+
+ protected $_definition;
+
+
+ protected $_shared = false;
+
+
+ protected $_resolved = false;
+
+
+ protected $_sharedInstance;
+
+
+ /**
+ * Phalcon\Di\Service
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param boolean $shared
+ */
+ public final function __construct($name, $definition, $shared = false) {}
+
+ /**
+ * Returns the service's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets if the service is shared or not
+ *
+ * @param bool $shared
+ */
+ public function setShared($shared) {}
+
+ /**
+ * Check whether the service is shared or not
+ *
+ * @return bool
+ */
+ public function isShared() {}
+
+ /**
+ * Sets/Resets the shared instance related to the service
+ *
+ * @param mixed $sharedInstance
+ */
+ public function setSharedInstance($sharedInstance) {}
+
+ /**
+ * Set the service definition
+ *
+ * @param mixed $definition
+ */
+ public function setDefinition($definition) {}
+
+ /**
+ * Returns the service definition
+ *
+ * @return mixed
+ */
+ public function getDefinition() {}
+
+ /**
+ * Resolves the service
+ *
+ * @param array $parameters
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @return mixed
+ */
+ public function resolve($parameters = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Changes a parameter in the definition without resolve the service
+ *
+ * @param int $position
+ * @param array $parameter
+ * @return Service
+ */
+ public function setParameter($position, $parameter) {}
+
+ /**
+ * Returns a parameter in a specific position
+ *
+ * @param int $position
+ * @return array
+ */
+ public function getParameter($position) {}
+
+ /**
+ * Returns true if the service was resolved
+ *
+ * @return bool
+ */
+ public function isResolved() {}
+
+ /**
+ * Restore the internal state of a service
+ *
+ * @param array $attributes
+ * @return Service
+ */
+ public static function __set_state($attributes) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/di/ServiceInterface.php b/ide/2.0.4/Phalcon/di/ServiceInterface.php
new file mode 100644
index 000000000..97df909cf
--- /dev/null
+++ b/ide/2.0.4/Phalcon/di/ServiceInterface.php
@@ -0,0 +1,73 @@
+
+ * $eventsManager->fire('db', $connection);
+ *
+ *
+ * @param string $eventType
+ * @param object $source
+ * @param mixed $data
+ * @param boolean $cancelable
+ * @return mixed
+ */
+ public function fire($eventType, $source, $data = null, $cancelable = true) {}
+
+ /**
+ * Check whether certain type of event has listeners
+ *
+ * @param string $type
+ * @return bool
+ */
+ public function hasListeners($type) {}
+
+ /**
+ * Returns all the attached listeners of a certain type
+ *
+ * @param string $type
+ * @return array
+ */
+ public function getListeners($type) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/events/ManagerInterface.php b/ide/2.0.4/Phalcon/events/ManagerInterface.php
new file mode 100644
index 000000000..394032467
--- /dev/null
+++ b/ide/2.0.4/Phalcon/events/ManagerInterface.php
@@ -0,0 +1,55 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * @return string
+ */
+ public function message($type, $message) {}
+
+<<<<<<< HEAD
+ /**
+ * Prints the messages accumulated in the flasher
+ *
+ * @param bool $remove
+ */
+ public function output($remove = true) {}
+
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/flash/Exception.php b/ide/2.0.4/Phalcon/flash/Exception.php
new file mode 100644
index 000000000..74c03d0a5
--- /dev/null
+++ b/ide/2.0.4/Phalcon/flash/Exception.php
@@ -0,0 +1,12 @@
+Encapsulates request information for easy and secure access from application controllers.
+ * The request object is a simple value object that is passed between the dispatcher and controller classes. + * It packages the HTTP request environment.
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146 + *
+ * $request = new \Phalcon\Http\Request();
+ * if ($request->isPost() == true) {
+ * if ($request->isAjax() == true) {
+ * echo 'Request was made using POST and AJAX';
+ * }
+ * }
+ *
+ */
+class Request implements \Phalcon\Http\RequestInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_rawBody;
+
+
+ protected $_filter;
+
+
+ protected $_putCache;
+
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Gets a variable from the $_REQUEST superglobal applying filters if needed.
+ * If no parameters are given the $_REQUEST superglobal is returned
+ *
+ * //Returns value from $_REQUEST["user_email"] without sanitizing
+ * $userEmail = $request->get("user_email");
+ * //Returns value from $_REQUEST["user_email"] with sanitizing
+ * $userEmail = $request->get("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function get($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from the $_POST superglobal applying filters if needed
+ * If no parameters are given the $_POST superglobal is returned
+ *
+ * //Returns value from $_POST["user_email"] without sanitizing
+ * $userEmail = $request->getPost("user_email");
+ * //Returns value from $_POST["user_email"] with sanitizing
+ * $userEmail = $request->getPost("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPost($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from put request
+ *
+ * //Returns value from $_PUT["user_email"] without sanitizing
+ * $userEmail = $request->getPut("user_email");
+ * //Returns value from $_PUT["user_email"] with sanitizing
+ * $userEmail = $request->getPut("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPut($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_GET superglobal applying filters if needed
+ * If no parameters are given the $_GET superglobal is returned
+ *
+ * //Returns value from $_GET["id"] without sanitizing
+ * $id = $request->getQuery("id");
+ * //Returns value from $_GET["id"] with sanitizing
+ * $id = $request->getQuery("id", "int");
+ * //Returns value from $_GET["id"] with a default value
+ * $id = $request->getQuery("id", null, 150);
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getQuery($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Helper to get data from superglobals, applying filters if needed.
+ * If no parameters are given the superglobal is returned.
+ *
+ * @param array $source
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ protected final function getHelper($source, $name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_SERVER superglobal
+ *
+ * @param string $name
+ */
+ public function getServer($name) {}
+
+ /**
+ * Checks whether $_REQUEST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Checks whether $_POST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPost($name) {}
+
+ /**
+ * Checks whether the PUT data has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPut($name) {}
+
+ /**
+ * Checks whether $_GET superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasQuery($name) {}
+
+ /**
+ * Checks whether $_SERVER superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public final function hasServer($name) {}
+
+ /**
+ * Gets HTTP header from request data
+ *
+ * @param string $header
+ * @return string
+ */
+ public final function getHeader($header) {}
+
+ /**
+ * Gets HTTP schema (http/https)
+ *
+ * @return string
+ */
+ public function getScheme() {}
+
+ /**
+ * Checks whether request has been made using ajax
+ *
+ * @return bool
+ */
+ public function isAjax() {}
+
+ /**
+ * Checks whether request has been made using SOAP
+ *
+ * @return bool
+ */
+ public function isSoapRequested() {}
+
+ /**
+ * Checks whether request has been made using any secure layer
+ *
+ * @return bool
+ */
+ public function isSecureRequest() {}
+
+ /**
+ * Gets HTTP raw request body
+ *
+ * @return string
+ */
+ public function getRawBody() {}
+
+ /**
+ * Gets decoded JSON HTTP raw request body
+ *
+ * @param bool $associative
+ * @return array|bool|\stdClass
+ */
+ public function getJsonRawBody($associative = false) {}
+
+ /**
+ * Gets active server address IP
+ *
+ * @return string
+ */
+ public function getServerAddress() {}
+
+ /**
+ * Gets active server name
+ *
+ * @return string
+ */
+ public function getServerName() {}
+
+ /**
+ * Gets information about schema, host and port used by the request
+ *
+ * @return string
+ */
+ public function getHttpHost() {}
+
+ /**
+ * Gets HTTP URI which request has been made
+ *
+ * @return string
+ */
+ public final function getURI() {}
+
+ /**
+ * Gets most possible client IPv4 Address. This method search in _SERVER['REMOTE_ADDR'] and optionally in _SERVER['HTTP_X_FORWARDED_FOR']
+ *
+ * @param bool $trustForwardedHeader
+ * @return string|bool
+ */
+ public function getClientAddress($trustForwardedHeader = false) {}
+
+ /**
+ * Gets HTTP method which request has been made
+ *
+ * @return string
+ */
+ public final function getMethod() {}
+
+ /**
+ * Gets HTTP user agent used to made the request
+ *
+ * @return string
+ */
+ public function getUserAgent() {}
+
+ /**
+<<<<<<< HEAD
+ * Checks if a method is a valid HTTP method
+ *
+ * @param string $method
+ * @return bool
+ */
+ public function isValidHttpMethod($method) {}
+
+ /**
+ * Check if HTTP method match any of the passed methods
+ * When strict is true it checks if validated methods are real HTTP methods
+ *
+ * @param mixed $methods
+ * @param bool $strict
+ * @return bool
+ */
+ public function isMethod($methods, $strict = false) {}
+=======
+ * Check if HTTP method match any of the passed methods
+ *
+ * @param mixed $methods
+ * @return bool
+ */
+ public function isMethod($methods) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Checks whether HTTP method is POST. if _SERVER["REQUEST_METHOD"]==="POST"
+ *
+ * @return bool
+ */
+ public function isPost() {}
+
+ /**
+ * Checks whether HTTP method is GET. if _SERVER["REQUEST_METHOD"]==="GET"
+ *
+ * @return bool
+ */
+ public function isGet() {}
+
+ /**
+ * Checks whether HTTP method is PUT. if _SERVER["REQUEST_METHOD"]==="PUT"
+ *
+ * @return bool
+ */
+ public function isPut() {}
+
+ /**
+ * Checks whether HTTP method is PATCH. if _SERVER["REQUEST_METHOD"]==="PATCH"
+ *
+ * @return bool
+ */
+ public function isPatch() {}
+
+ /**
+ * Checks whether HTTP method is HEAD. if _SERVER["REQUEST_METHOD"]==="HEAD"
+ *
+ * @return bool
+ */
+ public function isHead() {}
+
+ /**
+ * Checks whether HTTP method is DELETE. if _SERVER["REQUEST_METHOD"]==="DELETE"
+ *
+ * @return bool
+ */
+ public function isDelete() {}
+
+ /**
+ * Checks whether HTTP method is OPTIONS. if _SERVER["REQUEST_METHOD"]==="OPTIONS"
+ *
+ * @return bool
+ */
+ public function isOptions() {}
+
+ /**
+ * Checks whether request include attached files
+ *
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ public function hasFiles($onlySuccessful = false) {}
+
+ /**
+ * Recursively counts file in an array of files
+ *
+ * @param mixed $data
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ protected final function hasFileHelper($data, $onlySuccessful) {}
+
+ /**
+ * Gets attached files as Phalcon\Http\Request\File instances
+ *
+ * @param bool $onlySuccessful
+ * @return \Phalcon\Http\Request\File
+ */
+ public function getUploadedFiles($onlySuccessful = false) {}
+
+ /**
+ * Smooth out $_FILES to have plain array with all files uploaded
+ *
+ * @param array $names
+ * @param array $types
+ * @param array $tmp_names
+ * @param array $sizes
+ * @param array $errors
+ * @param string $prefix
+ * @return array
+ */
+ protected final function smoothFiles($names, $types, $tmp_names, $sizes, $errors, $prefix) {}
+
+ /**
+ * Returns the available headers in the request
+ *
+ * @return array
+ */
+ public function getHeaders() {}
+
+ /**
+ * Gets web page that refers active request. ie: http://www.google.com
+ *
+ * @return string
+ */
+ public function getHTTPReferer() {}
+
+ /**
+ * Process a request header and return an array of values with their qualities
+ *
+ * @param string $serverIndex
+ * @param string $name
+ * @return array
+ */
+ protected final function _getQualityHeader($serverIndex, $name) {}
+
+ /**
+ * Process a request header and return the one with best quality
+ *
+ * @param array $qualityParts
+ * @param string $name
+ * @return string
+ */
+ protected final function _getBestQuality($qualityParts, $name) {}
+
+ /**
+ * Gets content type which request has been made
+ *
+ * @return string|null
+ */
+ public function getContentType() {}
+
+ /**
+ * Gets an array with mime/types and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return array
+ */
+ public function getAcceptableContent() {}
+
+ /**
+ * Gets best mime/type accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return string
+ */
+ public function getBestAccept() {}
+
+ /**
+ * Gets a charsets array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return variable
+ */
+ public function getClientCharsets() {}
+
+ /**
+ * Gets best charset accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return string
+ */
+ public function getBestCharset() {}
+
+ /**
+ * Gets languages array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return array
+ */
+ public function getLanguages() {}
+
+ /**
+ * Gets best language accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return string
+ */
+ public function getBestLanguage() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_USER']
+ *
+ * @return array|null
+ */
+ public function getBasicAuth() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_DIGEST']
+ *
+ * @return array
+ */
+ public function getDigestAuth() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/http/RequestInterface.php b/ide/2.0.4/Phalcon/http/RequestInterface.php
new file mode 100644
index 000000000..15834a7ed
--- /dev/null
+++ b/ide/2.0.4/Phalcon/http/RequestInterface.php
@@ -0,0 +1,312 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Checks whether HTTP method is POST. if $_SERVER['REQUEST_METHOD']=='POST'
+ *
+ * @return bool
+ */
+ public function isPost();
+
+ /**
+ * Checks whether HTTP method is GET. if $_SERVER['REQUEST_METHOD']=='GET'
+ *
+ * @return bool
+ */
+ public function isGet();
+
+ /**
+ * Checks whether HTTP method is PUT. if $_SERVER['REQUEST_METHOD']=='PUT'
+ *
+ * @return bool
+ */
+ public function isPut();
+
+ /**
+ * Checks whether HTTP method is HEAD. if $_SERVER['REQUEST_METHOD']=='HEAD'
+ *
+ * @return bool
+ */
+ public function isHead();
+
+ /**
+ * Checks whether HTTP method is DELETE. if $_SERVER['REQUEST_METHOD']=='DELETE'
+ *
+ * @return bool
+ */
+ public function isDelete();
+
+ /**
+ * Checks whether HTTP method is OPTIONS. if $_SERVER['REQUEST_METHOD']=='OPTIONS'
+ *
+ * @return bool
+ */
+ public function isOptions();
+
+ /**
+ * Checks whether request include attached files
+ *
+ * @param boolean $onlySuccessful
+ * @return boolean
+ */
+ public function hasFiles($onlySuccessful = false);
+
+ /**
+ * Gets attached files as Phalcon\Http\Request\FileInterface compatible instances
+ *
+ * @param bool $onlySuccessful
+ * @return \Phalcon\Http\Request\FileInterface
+ */
+ public function getUploadedFiles($onlySuccessful = false);
+
+ /**
+ * Gets web page that refers active request. ie: http://www.google.com
+ *
+ * @return string
+ */
+ public function getHTTPReferer();
+
+ /**
+ * Gets array with mime/types and their quality accepted by the browser/client from $_SERVER['HTTP_ACCEPT']
+ *
+ * @return array
+ */
+ public function getAcceptableContent();
+
+ /**
+ * Gets best mime/type accepted by the browser/client from $_SERVER['HTTP_ACCEPT']
+ *
+ * @return string
+ */
+ public function getBestAccept();
+
+ /**
+ * Gets charsets array and their quality accepted by the browser/client from $_SERVER['HTTP_ACCEPT_CHARSET']
+ *
+ * @return array
+ */
+ public function getClientCharsets();
+
+ /**
+ * Gets best charset accepted by the browser/client from $_SERVER['HTTP_ACCEPT_CHARSET']
+ *
+ * @return string
+ */
+ public function getBestCharset();
+
+ /**
+ * Gets languages array and their quality accepted by the browser/client from _SERVER['HTTP_ACCEPT_LANGUAGE']
+ *
+ * @return array
+ */
+ public function getLanguages();
+
+ /**
+ * Gets best language accepted by the browser/client from $_SERVER['HTTP_ACCEPT_LANGUAGE']
+ *
+ * @return string
+ */
+ public function getBestLanguage();
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_USER']
+ *
+ * @return array
+ */
+ public function getBasicAuth();
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_DIGEST']
+ *
+ * @return array
+ */
+ public function getDigestAuth();
+
+}
diff --git a/ide/2.0.4/Phalcon/http/Response.php b/ide/2.0.4/Phalcon/http/Response.php
new file mode 100644
index 000000000..025a5ee79
--- /dev/null
+++ b/ide/2.0.4/Phalcon/http/Response.php
@@ -0,0 +1,293 @@
+
+ * $response = new \Phalcon\Http\Response();
+ * $response->setStatusCode(200, "OK");
+ * $response->setContent("Hello");
+ * $response->send();
+ *
+ */
+class Response implements \Phalcon\Http\ResponseInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_sent = false;
+
+
+ protected $_content;
+
+
+ protected $_headers;
+
+
+ protected $_cookies;
+
+
+ protected $_file;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_statusCodes;
+
+
+ /**
+ * Phalcon\Http\Response constructor
+ *
+ * @param string $content
+ * @param int $code
+ * @param string $status
+ */
+ public function __construct($content = null, $code = null, $status = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the HTTP response code
+ *
+ * $response->setStatusCode(404, "Not Found");
+ *
+ *
+ * @param int $code
+ * @param string $message
+ * @return Response
+ */
+ public function setStatusCode($code, $message = null) {}
+
+ /**
+ * Returns the status code
+ *
+ * print_r($response->getStatusCode());
+ *
+ *
+ * @return array
+ */
+ public function getStatusCode() {}
+
+ /**
+ * Sets a headers bag for the response externally
+ *
+ * @param mixed $headers
+ * @return Response
+ */
+ public function setHeaders(\Phalcon\Http\Response\HeadersInterface $headers) {}
+
+ /**
+ * Returns headers set by the user
+ *
+ * @return \Phalcon\Http\Response\HeadersInterface
+ */
+ public function getHeaders() {}
+
+ /**
+ * Sets a cookies bag for the response externally
+ *
+ * @param mixed $cookies
+ * @return Response
+ */
+ public function setCookies(\Phalcon\Http\Response\CookiesInterface $cookies) {}
+
+ /**
+ * Returns coookies set by the user
+ *
+ * @return \Phalcon\Http\Response\CookiesInterface
+ */
+ public function getCookies() {}
+
+ /**
+ * Overwrites a header in the response
+ *
+ * $response->setHeader("Content-Type", "text/plain");
+ *
+ *
+ * @param string $name
+ * @param string $value
+ * @return \Phalcon\Http\Response
+ */
+ public function setHeader($name, $value) {}
+
+ /**
+ * Send a raw header to the response
+ *
+ * $response->setRawHeader("HTTP/1.1 404 Not Found");
+ *
+ *
+ * @param string $header
+ * @return Response
+ */
+ public function setRawHeader($header) {}
+
+ /**
+ * Resets all the stablished headers
+ *
+ * @return Response
+ */
+ public function resetHeaders() {}
+
+ /**
+ * Sets a Expires header to use HTTP cache
+ *
+ * $this->response->setExpires(new DateTime());
+ *
+ *
+ * @param mixed $datetime
+ * @return Response
+ */
+ public function setExpires(\DateTime $datetime) {}
+
+ /**
+ * Sends a Not-Modified response
+ *
+ * @return Response
+ */
+ public function setNotModified() {}
+
+ /**
+ * Sets the response content-type mime, optionally the charset
+ *
+ * $response->setContentType('application/pdf');
+ * $response->setContentType('text/plain', 'UTF-8');
+ *
+ *
+ * @param string $contentType
+ * @param string $charset
+ * @return \Phalcon\Http\Response
+ */
+ public function setContentType($contentType, $charset = null) {}
+
+ /**
+ * Set a custom ETag
+ *
+ * $response->setEtag(md5(time()));
+ *
+ *
+ * @param string $etag
+ * @return Response
+ */
+ public function setEtag($etag) {}
+
+ /**
+ * Redirect by HTTP to another action or URL
+ *
+ * //Using a string redirect (internal/external)
+ * $response->redirect("posts/index");
+ * $response->redirect("http://en.wikipedia.org", true);
+ * $response->redirect("http://www.example.com/new-location", true, 301);
+ * //Making a redirection based on a named route
+ * $response->redirect(array(
+ * "for" => "index-lang",
+ * "lang" => "jp",
+ * "controller" => "index"
+ * ));
+ *
+ *
+ * @param string|array $location
+ * @param boolean $externalRedirect
+ * @param int $statusCode
+ * @return \Phalcon\Http\Response
+ */
+ public function redirect($location = null, $externalRedirect = false, $statusCode = 302) {}
+
+ /**
+ * Sets HTTP response body
+ *
+ * response->setContent("Hello!
");
+ *
+ *
+ * @param string $content
+ * @return Response
+ */
+ public function setContent($content) {}
+
+ /**
+ * Sets HTTP response body. The parameter is automatically converted to JSON
+ *
+ * $response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param mixed $content
+ * @param int $jsonOptions
+<<<<<<< HEAD
+ * @param mixed $depth
+ * @return \Phalcon\Http\Response
+ */
+ public function setJsonContent($content, $jsonOptions = 0, $depth = 512) {}
+=======
+ * @return \Phalcon\Http\Response
+ */
+ public function setJsonContent($content, $jsonOptions = 0) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\Response
+ */
+ public function appendContent($content) {}
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Check if the response is already sent
+ *
+ * @return bool
+ */
+ public function isSent() {}
+
+ /**
+ * Sends headers to the client
+ *
+ * @return Response
+ */
+ public function sendHeaders() {}
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return Response
+ */
+ public function sendCookies() {}
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return Response
+ */
+ public function send() {}
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @param mixed $attachment
+ * @return \Phalcon\Http\Response
+ */
+ public function setFileToSend($filePath, $attachmentName = null, $attachment = true) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/http/ResponseInterface.php b/ide/2.0.4/Phalcon/http/ResponseInterface.php
new file mode 100644
index 000000000..36f157f32
--- /dev/null
+++ b/ide/2.0.4/Phalcon/http/ResponseInterface.php
@@ -0,0 +1,150 @@
+
+ * response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function setJsonContent($content);
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function appendContent($content);
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent();
+
+ /**
+ * Sends headers to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendHeaders();
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendCookies();
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return ResponseInterface
+ */
+ public function send();
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @return ResponseInterface
+ */
+ public function setFileToSend($filePath, $attachmentName = null);
+
+}
diff --git a/ide/2.0.4/Phalcon/http/cookie/Exception.php b/ide/2.0.4/Phalcon/http/cookie/Exception.php
new file mode 100644
index 000000000..a3dbbd67d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/http/cookie/Exception.php
@@ -0,0 +1,12 @@
+
+ * class PostsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function uploadAction()
+ * {
+ * //Check if the user has uploaded files
+ * if ($this->request->hasFiles() == true) {
+ * //Print the real file names and their sizes
+ * foreach ($this->request->getUploadedFiles() as $file){
+ * echo $file->getName(), " ", $file->getSize(), "\n";
+ * }
+ * }
+ * }
+ * }
+ *
+ */
+class File implements \Phalcon\Http\Request\FileInterface
+{
+
+ protected $_name;
+
+
+ protected $_tmp;
+
+
+ protected $_size;
+
+
+ protected $_type;
+
+
+ protected $_realType;
+
+
+ protected $_error;
+
+
+ protected $_key;
+
+
+ protected $_extension;
+
+
+
+ public function getError() {}
+
+
+ public function getKey() {}
+
+
+ public function getExtension() {}
+
+ /**
+ * Phalcon\Http\Request\File constructor
+ *
+ * @param array $file
+ * @param mixed $key
+ */
+ public function __construct($file, $key = null) {}
+
+ /**
+ * Returns the file size of the uploaded file
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Returns the real name of the uploaded file
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Returns the temporal name of the uploaded file
+ *
+ * @return string
+ */
+ public function getTempName() {}
+
+ /**
+ * Returns the mime type reported by the browser
+ * This mime type is not completely secure, use getRealType() instead
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Gets the real mime type of the upload file using finfo
+ *
+ * @return string
+ */
+ public function getRealType() {}
+
+ /**
+ * Checks whether the file has been uploaded via Post.
+ *
+ * @return bool
+ */
+ public function isUploadedFile() {}
+
+ /**
+ * Moves the temporary file to a destination within the application
+ *
+ * @param string $destination
+ * @return bool
+ */
+ public function moveTo($destination) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/http/request/FileInterface.php b/ide/2.0.4/Phalcon/http/request/FileInterface.php
new file mode 100644
index 000000000..3e3109e86
--- /dev/null
+++ b/ide/2.0.4/Phalcon/http/request/FileInterface.php
@@ -0,0 +1,64 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/http/response/HeadersInterface.php b/ide/2.0.4/Phalcon/http/response/HeadersInterface.php
new file mode 100644
index 000000000..b2c62d52c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/http/response/HeadersInterface.php
@@ -0,0 +1,55 @@
+
+ * $image = new Phalcon\Image\Adapter\Imagick("upload/test.jpg");
+ * $image->resize(200, 200)->rotate(90)->crop(100, 100);
+ * if ($image->save()) {
+ * echo 'success';
+ * }
+ *
+ */
+class Imagick extends \Phalcon\Image\Adapter implements \Phalcon\Image\AdapterInterface
+{
+
+ static protected $_version = 0;
+
+
+ static protected $_checked = false;
+
+
+ /**
+ * Checks if Imagick is enabled
+ *
+ * @return bool
+ */
+ public static function check() {}
+
+ /**
+ * \Phalcon\Image\Adapter\Imagick constructor
+ *
+ * @param string $file
+ * @param int $width
+ * @param int $height
+ */
+ public function __construct($file, $width = null, $height = null) {}
+
+ /**
+ * Execute a resize.
+ *
+ * @param int $width
+ * @param int $height
+ */
+ protected function _resize($width, $height) {}
+
+ /**
+ * This method scales the images using liquid rescaling method. Only support Imagick
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $deltaX
+ * @param int $rigidity
+ * @param int $$width new width
+ * @param int $$height new height
+ * @param int $$deltaX How much the seam can traverse on x-axis. Passing 0 causes the seams to be straight.
+ * @param int $$rigidity Introduces a bias for non-straight seams. This parameter is typically 0.
+ */
+ protected function _liquidRescale($width, $height, $deltaX, $rigidity) {}
+
+ /**
+ * Execute a crop.
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $offsetX
+ * @param int $offsetY
+ */
+ protected function _crop($width, $height, $offsetX, $offsetY) {}
+
+ /**
+ * Execute a rotation.
+ *
+ * @param int $degrees
+ */
+ protected function _rotate($degrees) {}
+
+ /**
+ * Execute a flip.
+ *
+ * @param int $direction
+ */
+ protected function _flip($direction) {}
+
+ /**
+ * Execute a sharpen.
+ *
+ * @param int $amount
+ */
+ protected function _sharpen($amount) {}
+
+ /**
+ * Execute a reflection.
+ *
+ * @param int $height
+ * @param int $opacity
+ * @param bool $fadeIn
+ */
+ protected function _reflection($height, $opacity, $fadeIn) {}
+
+ /**
+ * Execute a watermarking.
+ *
+ * @param mixed $image
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ */
+ protected function _watermark(\Phalcon\Image\Adapter $image, $offsetX, $offsetY, $opacity) {}
+
+ /**
+ * Execute a text
+ *
+ * @param string $text
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $size
+ * @param string $fontfile
+ */
+ protected function _text($text, $offsetX, $offsetY, $opacity, $r, $g, $b, $size, $fontfile) {}
+
+ /**
+ * Composite one image onto another
+ *
+ * @param mixed $image
+ * @param Adapter $$mask mask Image instance
+ */
+ protected function _mask(\Phalcon\Image\Adapter $image) {}
+
+ /**
+ * Execute a background.
+ *
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $opacity
+ */
+ protected function _background($r, $g, $b, $opacity) {}
+
+ /**
+ * Blur image
+ *
+ * @param int $radius
+ * @param int $$radius Blur radius
+ */
+ protected function _blur($radius) {}
+
+ /**
+ * Pixelate image
+ *
+ * @param int $amount
+ * @param int $$amount amount to pixelate
+ */
+ protected function _pixelate($amount) {}
+
+ /**
+ * Execute a save.
+ *
+ * @param string $file
+ * @param int $quality
+ */
+ protected function _save($file, $quality) {}
+
+ /**
+ * Execute a render.
+ *
+ * @param string $extension
+ * @param int $quality
+ * @return string
+ */
+ protected function _render($extension, $quality) {}
+
+ /**
+ * Destroys the loaded image to free up resources.
+ */
+ public function __destruct() {}
+
+ /**
+ * Get instance
+ *
+ * @return \Imagick
+ */
+ public function getInternalImInstance() {}
+
+ /**
+ * Sets the limit for a particular resource in megabytes
+ *
+ * @param int $type Refer to the list of resourcetype constants (@see http://php.net/manual/ru/imagick.constants.php#imagick.constants.resourcetypes.)
+ * @param int $limit The resource limit. The unit depends on the type of the resource being limited.
+ */
+ public function setResourceLimit($type, $limit) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/loader/Exception.php b/ide/2.0.4/Phalcon/loader/Exception.php
new file mode 100644
index 000000000..0732e2934
--- /dev/null
+++ b/ide/2.0.4/Phalcon/loader/Exception.php
@@ -0,0 +1,12 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ * $logger->close();
+ *
+ */
+class File extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_fileHandler;
+
+ /**
+ * File Path
+ */
+ protected $_path;
+
+ /**
+ * Path options
+ */
+ protected $_options;
+
+
+ /**
+ * File Path
+ */
+ public function getPath() {}
+
+ /**
+ * Phalcon\Logger\Adapter\File constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the file itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Opens the internal file handler after unserialization
+ */
+ public function __wakeup() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/logger/adapter/Firephp.php b/ide/2.0.4/Phalcon/logger/adapter/Firephp.php
new file mode 100644
index 000000000..8066f6805
--- /dev/null
+++ b/ide/2.0.4/Phalcon/logger/adapter/Firephp.php
@@ -0,0 +1,52 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Firephp("");
+ * $logger->log(\Phalcon\Logger::ERROR, "This is an error");
+ * $logger->error("This is another error");
+ *
+ */
+class Firephp extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ static private $_initialized;
+
+
+ static private $_index;
+
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @see http://www.firephp.org/Wiki/Reference/Protocol
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param string $$message
+ * @param int $$type
+ * @param int $$time
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/logger/adapter/Stream.php b/ide/2.0.4/Phalcon/logger/adapter/Stream.php
new file mode 100644
index 000000000..dd26d9015
--- /dev/null
+++ b/ide/2.0.4/Phalcon/logger/adapter/Stream.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Stream("php://stderr");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Stream extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_stream;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Stream constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/logger/adapter/Syslog.php b/ide/2.0.4/Phalcon/logger/adapter/Syslog.php
new file mode 100644
index 000000000..cc0eb1569
--- /dev/null
+++ b/ide/2.0.4/Phalcon/logger/adapter/Syslog.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Syslog("ident", array(
+ * 'option' => LOG_NDELAY,
+ * 'facility' => LOG_MAIL
+ * ));
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Syslog extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ protected $_opened = false;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Syslog constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\Formatter\Syslog
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return boolean
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/logger/formatter/Firephp.php b/ide/2.0.4/Phalcon/logger/formatter/Firephp.php
new file mode 100644
index 000000000..567c7aee9
--- /dev/null
+++ b/ide/2.0.4/Phalcon/logger/formatter/Firephp.php
@@ -0,0 +1,71 @@
+
+ * class Application extends \Phalcon\Mvc\Application
+ * {
+ * /
+ * Register the services here to make them general or register
+ * in the ModuleDefinition to make them module-specific
+ * \/
+ * protected function _registerServices()
+ * {
+ * }
+ * /
+ * This method registers all the modules in the application
+ * \/
+ * public function main()
+ * {
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ * }
+ * }
+ * $application = new Application();
+ * $application->main();
+ *
+ */
+class Application extends \Phalcon\Di\Injectable
+{
+
+ protected $_defaultModule;
+
+
+ protected $_modules;
+
+
+ protected $_implicitView = true;
+
+
+ /**
+ * Phalcon\Mvc\Application
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * By default. The view is implicitly buffering all the output
+ * You can full disable the view component using this method
+ *
+ * @param bool $implicitView
+ * @return Application
+ */
+ public function useImplicitView($implicitView) {}
+
+ /**
+ * Register an array of modules present in the application
+ *
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ * @param bool $merge
+ * @return Application
+ */
+ public function registerModules($modules, $merge = false) {}
+
+ /**
+ * Return the modules registered in the application
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Gets the module definition registered in the application via module name
+ *
+ * @param string $name
+ * @return array|object
+ */
+ public function getModule($name) {}
+
+ /**
+ * Sets the module name to be used if the router doesn't return a valid module
+ *
+ * @param string $defaultModule
+ * @return Application
+ */
+ public function setDefaultModule($defaultModule) {}
+
+ /**
+ * Returns the default module name
+ *
+ * @return string
+ */
+ public function getDefaultModule() {}
+
+ /**
+ * Handles a MVC request
+ *
+ * @param string $uri
+ * @return \Phalcon\Http\ResponseInterface|boolean
+ */
+ public function handle($uri = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/Collection.php b/ide/2.0.4/Phalcon/mvc/Collection.php
new file mode 100644
index 000000000..500bf9a69
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/Collection.php
@@ -0,0 +1,612 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+{
+
+ const OP_NONE = 0;
+
+
+ const OP_CREATE = 1;
+
+
+ const OP_UPDATE = 2;
+
+
+ const OP_DELETE = 3;
+
+
+ protected $_id;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_modelsManager;
+
+
+ protected $_source;
+
+
+ protected $_operationMade = 0;
+
+
+ protected $_connection;
+
+
+ protected $_errorMessages;
+
+
+ static protected $_reserved;
+
+
+ static protected $_disableEvents;
+
+
+ protected $_skipped = false;
+
+
+ /**
+ * Phalcon\Mvc\Collection constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param mixed $modelsManager
+ */
+ public final function __construct(\Phalcon\DiInterface $dependencyInjector = null, \Phalcon\Mvc\Collection\ManagerInterface $modelsManager = null) {}
+
+ /**
+ * Sets a value for the _id property, creates a MongoId object if needed
+ *
+ * @param mixed $id
+ */
+ public function setId($id) {}
+
+ /**
+ * Returns the value of the _id property
+ *
+ * @return \MongoId
+ */
+ public function getId() {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a custom events manager
+ *
+ * @param mixed $eventsManager
+ */
+ protected function setEventsManager(\Phalcon\Mvc\Collection\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the custom events manager
+ *
+ * @return \Phalcon\Mvc\Collection\ManagerInterface
+ */
+ protected function getEventsManager() {}
+
+ /**
+ * Returns the models manager related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Collection\ManagerInterface
+ */
+ public function getCollectionManager() {}
+
+ /**
+ * Returns an array with reserved properties that cannot be part of the insert/update
+ *
+ * @return array
+ */
+ public function getReservedAttributes() {}
+
+ /**
+ * Sets if a model must use implicit objects ids
+ *
+ * @param bool $useImplicitObjectIds
+ */
+ protected function useImplicitObjectIds($useImplicitObjectIds) {}
+
+ /**
+ * Sets collection name which model should be mapped
+ *
+ * @param string $source
+ * @return Collection
+ */
+ protected function setSource($source) {}
+
+ /**
+ * Returns collection name mapped in the model
+ *
+ * @return string
+ */
+ public function getSource() {}
+
+ /**
+ * Sets the DependencyInjection connection service name
+ *
+ * @param string $connectionService
+ * @return Collection
+ */
+ public function setConnectionService($connectionService) {}
+
+ /**
+ * Returns DependencyInjection connection service
+ *
+ * @return string
+ */
+ public function getConnectionService() {}
+
+ /**
+ * Retrieves a database connection
+ *
+ * @return \MongoDb
+ */
+ public function getConnection() {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+<<<<<<< HEAD
+ * echo $robot->readAttribute('name');
+=======
+ * echo robot->readAttribute('name');
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+<<<<<<< HEAD
+ * $robot->writeAttribute('name', 'Rosey');
+=======
+ * robot->writeAttribute('name', 'Rosey');
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns a cloned collection
+ *
+ * @param mixed $collection
+ * @param array $document
+ * @return CollectionInterface
+ */
+ public static function cloneResult(CollectionInterface $collection, $document) {}
+
+ /**
+ * Returns a collection resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @param boolean $unique
+ * @return array
+ */
+ protected static function _getResultset($params, CollectionInterface $collection, $connection, $unique) {}
+
+ /**
+ * Perform a count over a resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @return int
+ */
+ protected static function _getGroupResultset($params, Collection $collection, $connection) {}
+
+ /**
+ * Executes internal hooks before save a document
+ *
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @param boolean $disableEvents
+ * @param boolean $exists
+ * @return boolean
+ */
+ protected final function _preSave($dependencyInjector, $disableEvents, $exists) {}
+
+ /**
+ * Executes internal events after save a document
+ *
+ * @param bool $disableEvents
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected final function _postSave($disableEvents, $success, $exists) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Fires an internal event
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an internal event that cancels the operation
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ *
+ * @param bool $disableEvents
+ * @return bool
+ */
+ protected function _cancelOperation($disableEvents) {}
+
+ /**
+ * Checks if the document exists in the collection
+ *
+ * @param \MongoCollection $collection
+ * @return boolean
+ */
+ protected function _exists($collection) {}
+
+ /**
+ * Returns all the validation messages
+ *
+<<<<<<< HEAD
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as message) {
+=======
+ * robot = new Robots();
+ * robot->type = 'mechanical';
+ * robot->name = 'Astro Boy';
+ * robot->year = 1952;
+ * if (robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach (robot->getMessages() as message) {
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+<<<<<<< HEAD
+ * if ($this->name == 'Peter') {
+ * message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage(message);
+=======
+ * if (this->name == 'Peter') {
+ * message = new Message("Sorry, but a robot cannot be named Peter");
+ * this->appendMessage(message);
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Creates/Updates a collection based on the values in the atributes
+ *
+ * @return bool
+ */
+ public function save() {}
+
+ /**
+ * Find a document by its id (_id)
+ *
+ * @param string|\MongoId $id
+ * @return \Phalcon\Mvc\Collection
+ */
+ public static function findById($id) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in the robots table?
+<<<<<<< HEAD
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name, "\n";
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "The first mechanical robot name is ", $robot->name, "\n";
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array(
+ * array("type" => "mechanical"),
+ * "order" => array("name" => 1)
+ * ));
+ * echo "The first virtual robot name is ", $robot->name, "\n";
+=======
+ * robot = Robots::findFirst();
+ * echo "The robot name is ", robot->name, "\n";
+ * //What's the first mechanical robot in robots table?
+ * robot = Robots::findFirst(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "The first mechanical robot name is ", robot->name, "\n";
+ * //Get first virtual robot ordered by name
+ * robot = Robots::findFirst(array(
+ * array("type" => "mechanical"),
+ * "order" => array("name" => 1)
+ * ));
+ * echo "The first virtual robot name is ", robot->name, "\n";
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+<<<<<<< HEAD
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ * //How many mechanical robots are there?
+ * $robots = Robots::find(array(
+=======
+ * robots = Robots::find();
+ * echo "There are ", count(robots), "\n";
+ * //How many mechanical robots are there?
+ * robots = Robots::find(array(
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * array("type" => "mechanical")
+ * ));
+ * echo "There are ", count(robots), "\n";
+ * //Get and print virtual robots ordered by name
+<<<<<<< HEAD
+ * $robots = Robots::findFirst(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1)
+ * ));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array(
+=======
+ * robots = Robots::findFirst(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1)
+ * ));
+ * foreach (robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * robots = Robots::find(array(
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1),
+ * "limit" => 100
+ * ));
+<<<<<<< HEAD
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+=======
+ * foreach (robots as robot) {
+ * echo robot->name, "\n";
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * }
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Perform a count over a collection
+ *
+ * echo 'There are ', Robots::count(), ' robots';
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Perform an aggregation using the Mongo aggregation framework
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function aggregate($parameters = null) {}
+
+ /**
+ * Allows to perform a summatory group for a column in the collection
+ *
+ * @param string $field
+<<<<<<< HEAD
+ * @param mixed $conditions
+ * @param mixed $finalize
+=======
+ * @param array $conditions
+ * @param string $finalize
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * @return array
+ */
+ public static function summatory($field, $conditions = null, $finalize = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+<<<<<<< HEAD
+ * $robot = Robots::findFirst();
+ * $robot->delete();
+ * foreach (Robots::find() as $robot) {
+ * $robot->delete();
+=======
+ * robot = Robots::findFirst();
+ * robot->delete();
+ * foreach (Robots::find() as robot) {
+ * robot->delete();
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+<<<<<<< HEAD
+ * Sets up a behavior in a collection
+ *
+ * @param mixed $behavior
+ */
+ protected function addBehavior(\Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r($robot->toArray());
+=======
+ * Returns the instance as an array representation
+ *
+ * print_r(robot->to[]);
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Serializes the object ignoring connections or protected properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+<<<<<<< HEAD
+=======
+ /**
+ * Sets up a behavior in a collection
+ *
+ * @param mixed $behavior
+ */
+ protected function addBehavior(\Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/mvc/CollectionInterface.php b/ide/2.0.4/Phalcon/mvc/CollectionInterface.php
new file mode 100644
index 000000000..31cad9b35
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/CollectionInterface.php
@@ -0,0 +1,167 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Returns a cloned collection
+ *
+ * @param mixed $collection
+ * @param array $document
+ * @return CollectionInterface
+ */
+ public static function cloneResult(CollectionInterface $collection, $document);
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName);
+
+ /**
+ * Fires an event, implicitly listeners in the events manager are notified
+ * This method stops if one of the callbacks/listeners returns boolean false
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName);
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * @return bool
+ */
+ public function validationHasFailed();
+
+ /**
+ * Returns all the validation messages
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages();
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message);
+
+ /**
+ * Creates/Updates a collection based on the values in the atributes
+ *
+ * @return bool
+ */
+ public function save();
+
+ /**
+ * Find a document by its id
+ *
+ * @param string $id
+ * @return \Phalcon\Mvc\Collection
+ */
+ public static function findById($id);
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function findFirst($parameters = null);
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * @param array $parameters
+ * @param $array parameters
+ * @return array
+ */
+ public static function find($parameters = null);
+
+ /**
+ * Perform a count over a collection
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function count($parameters = null);
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise
+ *
+ * @return bool
+ */
+ public function delete();
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/Controller.php b/ide/2.0.4/Phalcon/mvc/Controller.php
new file mode 100644
index 000000000..4abb725d3
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/Controller.php
@@ -0,0 +1,42 @@
+
+ * dispatcher->forward(array('controller' => 'people', 'action' => 'index'));
+ * }
+ * }
+ *
+ */
+<<<<<<< HEAD
+abstract class Controller extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ControllerInterface
+=======
+abstract class Controller extends \Phalcon\Di\Injectable
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+{
+
+ /**
+ * Phalcon\Mvc\Controller constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/ControllerInterface.php b/ide/2.0.4/Phalcon/mvc/ControllerInterface.php
new file mode 100644
index 000000000..a46083149
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/ControllerInterface.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Mvc\Dispatcher();
+ * $dispatcher->setDI($di);
+ * $dispatcher->setControllerName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $controller = $dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher implements \Phalcon\Mvc\DispatcherInterface
+{
+
+ protected $_handlerSuffix = "Controller";
+
+
+ protected $_defaultHandler = "index";
+
+
+ protected $_defaultAction = "index";
+
+
+ /**
+ * Sets the default controller suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the controller name to be dispatched
+ *
+ * @param string $controllerName
+ */
+ public function setControllerName($controllerName) {}
+
+ /**
+ * Gets last dispatched controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets previous dispatched controller name
+ *
+ * @return string
+ */
+ public function getPreviousControllerName() {}
+
+ /**
+ * Gets previous dispatched action name
+ *
+ * @return string
+ */
+ public function getPreviousActionName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Possible controller class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getControllerClass() {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getLastController() {}
+
+ /**
+ * Returns the active controller in the dispatcher
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getActiveController() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/DispatcherInterface.php b/ide/2.0.4/Phalcon/mvc/DispatcherInterface.php
new file mode 100644
index 000000000..d232517a7
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/DispatcherInterface.php
@@ -0,0 +1,54 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $app->get('/say/welcome/{name}', function ($name) {
+ * echo "
+ * $app['request'] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $alias
+ * @param mixed $definition
+ */
+ public function offsetSet($alias, $definition) {}
+
+ /**
+ * Allows to obtain a shared service in the internal services container using the array syntax
+ *
+ * var_dump($di['request']);
+ *
+ *
+ * @param string $alias
+ * @return mixed
+ */
+ public function offsetGet($alias) {}
+
+ /**
+ * Removes a service from the internal services container using the array syntax
+ *
+ * @param string $alias
+ */
+ public function offsetUnset($alias) {}
+
+ /**
+ * Appends a before middleware to be called before execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function before($handler) {}
+
+ /**
+ * Appends an 'after' middleware to be called after execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function after($handler) {}
+
+ /**
+ * Appends a 'finish' middleware to be called when the request is finished
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function finish($handler) {}
+
+ /**
+ * Returns the internal handlers attached to the application
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/Model.php b/ide/2.0.4/Phalcon/mvc/Model.php
new file mode 100644
index 000000000..fe53b1452
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/Model.php
@@ -0,0 +1,1228 @@
+Phalcon\Mvc\Model connects business objects and database tables to create
+ * a persistable domain model where logic and data are presented in one wrapping.
+ * It‘s an implementation of the object-relational mapping (ORM).
+ * A model represents the information (data) of the application and the rules to manipulate that data. + * Models are primarily used for managing the rules of interaction with a corresponding database table. + * In most cases, each table in your database will correspond to one model in your application. + * The bulk of your application's business logic will be concentrated in the models.
+ *Phalcon\Mvc\Model is the first ORM written in C-language for PHP, giving to developers high performance + * when interacting with databases while is also easy to use.
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146 + *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can store robots: ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ */
+<<<<<<< HEAD
+abstract class Model implements \Phalcon\Mvc\EntityInterface, \Phalcon\Mvc\ModelInterface, \Phalcon\Mvc\Model\ResultInterface, \Phalcon\Di\InjectionAwareInterface, \Serializable
+=======
+abstract class Model implements \Phalcon\Mvc\ModelInterface, \Phalcon\Mvc\Model\ResultInterface, \Phalcon\Di\InjectionAwareInterface, \Serializable
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+{
+
+ const OP_NONE = 0;
+
+
+ const OP_CREATE = 1;
+
+
+ const OP_UPDATE = 2;
+
+
+ const OP_DELETE = 3;
+
+
+ const DIRTY_STATE_PERSISTENT = 0;
+
+
+ const DIRTY_STATE_TRANSIENT = 1;
+
+
+ const DIRTY_STATE_DETACHED = 2;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_modelsManager;
+
+
+ protected $_modelsMetaData;
+
+
+ protected $_errorMessages;
+
+
+ protected $_operationMade = 0;
+
+
+ protected $_dirtyState = 1;
+
+
+ protected $_transaction;
+
+
+ protected $_uniqueKey;
+
+
+ protected $_uniqueParams;
+
+
+ protected $_uniqueTypes;
+
+
+ protected $_skipped;
+
+
+ protected $_related;
+
+
+ protected $_snapshot;
+
+
+ /**
+ * Phalcon\Mvc\Model constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param mixed $modelsManager
+ */
+ public final function __construct(\Phalcon\DiInterface $dependencyInjector = null, \Phalcon\Mvc\Model\ManagerInterface $modelsManager = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a custom events manager
+ *
+ * @param mixed $eventsManager
+ */
+ protected function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the custom events manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ protected function getEventsManager() {}
+
+ /**
+ * Returns the models meta-data service related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\MetaDataInterface
+ */
+ public function getModelsMetaData() {}
+
+ /**
+ * Returns the models manager related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\ManagerInterface
+ */
+ public function getModelsManager() {}
+
+ /**
+ * Sets a transaction related to the Model instance
+ *
+ * use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
+ * use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
+ * try {
+ * $txManager = new TxManager();
+ * $transaction = $txManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Robot part cannot be saved");
+ * }
+ * $transaction->commit();
+ * } catch (TxFailed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ *
+ * @param mixed $transaction
+ * @return Model
+ */
+ public function setTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Sets table name which model should be mapped
+ *
+ * @param string $source
+ * @return Model
+ */
+ protected function setSource($source) {}
+
+ /**
+ * Returns table name mapped in the model
+ *
+ * @return string
+ */
+ public function getSource() {}
+
+ /**
+ * Sets schema name where table mapped is located
+ *
+ * @param string $schema
+ * @return Model
+ */
+ protected function setSchema($schema) {}
+
+ /**
+ * Returns schema name where table mapped is located
+ *
+ * @return string
+ */
+ public function getSchema() {}
+
+ /**
+ * Sets the DependencyInjection connection service name
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to read data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setReadConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to write data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setWriteConnectionService($connectionService) {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to read data related the model
+ *
+ * @return string
+ */
+ public function getReadConnectionService() {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to write data related to the model
+ *
+ * @return string
+ */
+ public function getWriteConnectionService() {}
+
+ /**
+ * Sets the dirty state of the object using one of the DIRTY_STATE_* constants
+ *
+ * @param int $dirtyState
+ * @return ModelInterface
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not
+ *
+ * @return int
+ */
+ public function getDirtyState() {}
+
+ /**
+ * Gets the connection used to read data for the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection() {}
+
+ /**
+ * Gets the connection used to write data to the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection() {}
+
+ /**
+ * Assigns values to a model from an array
+ *
+ * $robot->assign(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ * //assign by db row, column map needed
+ * $robot->assign($dbRow, array(
+ * 'db_type' => 'type',
+ * 'db_name' => 'name',
+ * 'db_year' => 'year'
+ * ));
+ * //allow assign only name and year
+ * $robot->assign($_POST, null, array('name', 'year');
+ *
+ *
+ * @param array $data
+ * @param array $dataColumnMap array to transform keys of data to another
+ * @param array $whiteList
+ * @return \Phalcon\Mvc\Model
+ */
+ public function assign($data, $dataColumnMap = null, $whiteList = null) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model.
+ *
+ * $robot = \Phalcon\Mvc\Model::cloneResultMap(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface|\Phalcon\Mvc\Model\Row $base
+ * @param array $data
+ * @param array $columnMap
+ * @param int $dirtyState
+ * @param boolean $keepSnapshots
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function cloneResultMap($base, $data, $columnMap, $dirtyState = 0, $keepSnapshots = null) {}
+
+ /**
+ * Returns an hydrated result based on the data and the column map
+ *
+ * @param array $data
+ * @param array $columnMap
+ * @param int $hydrationMode
+ * @return mixed
+ */
+ public static function cloneResultMapHydrate($data, $columnMap, $hydrationMode) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model
+ *
+ * $robot = Phalcon\Mvc\Model::cloneResult(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param mixed $base
+ * @param array $data
+ * @param int $dirtyState
+ * @param \Phalcon\Mvc\ModelInterface $$base
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public static function cloneResult(ModelInterface $base, $data, $dirtyState = 0) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ * //How many mechanical robots are there?
+ * $robots = Robots::find("type='mechanical'");
+ * echo "There are ", count($robots), "\n";
+ * //Get and print virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name", "limit" => 100));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ *
+ * @param mixed $parameters
+ * @param $array parameters
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in robots table?
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name;
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst("type='mechanical'");
+ * echo "The first mechanical robot name is ", $robot->name;
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array("type='virtual'", "order" => "name"));
+ * echo "The first virtual robot name is ", $robot->name;
+ *
+ *
+<<<<<<< HEAD
+ * @param string|array $parameters
+=======
+ * @param array $parameters
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Create a criteria for a specific model
+ *
+ * @param mixed $dependencyInjector
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public static function query(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Checks if the current record already exists or not
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _exists(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table = null) {}
+
+ /**
+ * Generate a PHQL SELECT statement for an aggregate
+ *
+ * @param string $functionName
+ * @param string $alias
+ * @param array $parameters
+ * @param string $function
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected static function _groupResult($functionName, $alias, $parameters) {}
+
+ /**
+ * Allows to count how many records match the specified conditions
+ *
+ * //How many robots are there?
+ * $number = Robots::count();
+ * echo "There are ", $number, "\n";
+ * //How many mechanical robots are there?
+ * $number = Robots::count("type='mechanical'");
+ * echo "There are ", $number, " mechanical robots\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Allows to calculate a summatory on a column that match the specified conditions
+ *
+ * //How much are all robots?
+ * $sum = Robots::sum(array('column' => 'price'));
+ * echo "The total price of robots is ", $sum, "\n";
+ * //How much are mechanical robots?
+ * $sum = Robots::sum(array("type='mechanical'", 'column' => 'price'));
+ * echo "The total price of mechanical robots is ", $sum, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function sum($parameters = null) {}
+
+ /**
+ * Allows to get the maximum value of a column that match the specified conditions
+ *
+ * //What is the maximum robot id?
+ * $id = Robots::maximum(array('column' => 'id'));
+ * echo "The maximum robot id is: ", $id, "\n";
+ * //What is the maximum id of mechanical robots?
+ * $sum = Robots::maximum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The maximum robot id of mechanical robots is ", $id, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function maximum($parameters = null) {}
+
+ /**
+ * Allows to get the minimum value of a column that match the specified conditions
+ *
+ * //What is the minimum robot id?
+ * $id = Robots::minimum(array('column' => 'id'));
+ * echo "The minimum robot id is: ", $id;
+ * //What is the minimum id of mechanical robots?
+ * $sum = Robots::minimum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The minimum robot id of mechanical robots is ", $id;
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function minimum($parameters = null) {}
+
+ /**
+ * Allows to calculate the average value on a column matching the specified conditions
+ *
+ * //What's the average price of robots?
+ * $average = Robots::average(array('column' => 'price'));
+ * echo "The average price is ", $average, "\n";
+ * //What's the average price of mechanical robots?
+ * $average = Robots::average(array("type='mechanical'", 'column' => 'price'));
+ * echo "The average price of mechanical robots is ", $average, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return double
+ */
+ public static function average($parameters = null) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ * This method stops if one of the callbacks/listeners returns boolean false
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ */
+ protected function _cancelOperation() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if ($this->name == 'Peter') {
+ * $message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage($message);
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ * @return Model
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ * @return Model
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Returns all the validation messages
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo $message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @param mixed $filter
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages($filter = null) {}
+
+ /**
+ * Reads "belongs to" relations and check the virtual foreign keys when inserting or updating records
+ * to verify that inserted/updated values are present in the related entity
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysRestrict() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (cascade) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseCascade() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (restrict) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseRestrict() {}
+
+ /**
+ * Executes internal hooks before save a record
+ *
+ * @param mixed $metaData
+ * @param bool $exists
+ * @param mixed $identityField
+ * @return bool
+ */
+ protected function _preSave(\Phalcon\Mvc\Model\MetadataInterface $metaData, $exists, $identityField) {}
+
+ /**
+ * Executes internal events after save a record
+ *
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected function _postSave($success, $exists) {}
+
+ /**
+ * Sends a pre-build INSERT SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @param boolean|string $identityField
+ * @return boolean
+ */
+ protected function _doLowInsert(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table, $identityField) {}
+
+ /**
+ * Sends a pre-build UPDATE SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetaDataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _doLowUpdate(\Phalcon\Mvc\Model\MetaDataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table) {}
+
+ /**
+ * Saves related records that must be stored prior to save the master record
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _preSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Save the related records assigned in the has-one/has-many relations
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _postSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Inserts or updates a model instance. Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->save();
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->save();
+ *
+ *
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+ */
+ public function save($data = null, $whiteList = null) {}
+
+ /**
+ * Inserts a model instance. If the instance already exists in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->create();
+ * //Passing an array to create
+ * $robot = new Robots();
+ * $robot->create(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astroy Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+<<<<<<< HEAD
+ * @param mixed $data
+ * @param mixed $whiteList
+ * @return bool
+=======
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function create($data = null, $whiteList = null) {}
+
+ /**
+ * Updates a model instance. If the instance doesn't exist in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->update();
+ *
+ *
+<<<<<<< HEAD
+ * @param mixed $data
+ * @param mixed $whiteList
+ * @return bool
+=======
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function update($data = null, $whiteList = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ * $robot = Robots::findFirst("id=100");
+ * $robot->delete();
+ * foreach (Robots::find("type = 'mechanical'") as $robot) {
+ * $robot->delete();
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+ * Returns the type of the latest operation performed by the ORM
+ * Returns one of the OP_* class constants
+ *
+ * @return int
+ */
+ public function getOperationMade() {}
+
+ /**
+ * Refreshes the model attributes re-querying the record from the database
+ *
+ * @return Model
+ */
+ public function refresh() {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT/UPDATE statement
+ *
+ * skipAttributes(array('price'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributes($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT statement
+ *
+ * skipAttributesOnCreate(array('created_at'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnCreate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * skipAttributesOnUpdate(array('modified_in'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnUpdate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * allowEmptyStringValues(array('name'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function allowEmptyStringValues($attributes) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * hasOne('id', 'RobotsDescription', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasOne($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse 1-1 between two models
+ *
+ * belongsTo('robots_id', 'Robots', 'id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function belongsTo($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * hasMany('id', 'RobotsParts', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasMany($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation n-n between two models through an intermediate relation
+ *
+ * hasManyToMany(
+ * 'id',
+ * 'RobotsParts',
+ * 'robots_id',
+ * 'parts_id',
+ * 'Parts',
+ * 'id'
+ * );
+ * }
+ * }
+ *
+ *
+ * @param string|array fields
+ * @param string intermediateModel
+ * @param string|array intermediateFields
+ * @param string|array intermediateReferencedFields
+ * @param string referencedModel
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referenceModel
+ * @param string|array $referencedFields
+ * @param array $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasManyToMany($fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a behavior in a model
+ *
+ * addBehavior(new Timestampable(array(
+ * 'onCreate' => array(
+ * 'field' => 'created_at',
+ * 'format' => 'Y-m-d'
+ * )
+ * )));
+ * }
+ * }
+ *
+ *
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if the model must keep the original record snapshot in memory
+ *
+ * keepSnapshots(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $keepSnapshot
+ */
+ protected function keepSnapshots($keepSnapshot) {}
+
+ /**
+ * Sets the record's snapshot data.
+ * This method is used internally to set snapshot data when the model was set up to keep snapshot data
+ *
+ * @param array $data
+ * @param array $columnMap
+ */
+ public function setSnapshotData($data, $columnMap = null) {}
+
+ /**
+ * Checks if the object has internal snapshot data
+ *
+ * @return bool
+ */
+ public function hasSnapshotData() {}
+
+ /**
+ * Returns the internal snapshot data
+ *
+ * @return array
+ */
+ public function getSnapshotData() {}
+
+ /**
+ * Check if a specific attribute has changed
+ * This only works if the model is keeping data snapshots
+ *
+ * @param string|array $fieldName
+ * @return bool
+ */
+ public function hasChanged($fieldName = null) {}
+
+ /**
+ * Returns a list of changed values
+ *
+ * @return array
+ */
+ public function getChangedFields() {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * useDynamicUpdate(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $dynamicUpdate
+ */
+ protected function useDynamicUpdate($dynamicUpdate) {}
+
+ /**
+ * Returns related records based on defined relations
+ *
+ * @param string $alias
+ * @param array $arguments
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getRelated($alias, $arguments = null) {}
+
+ /**
+ * Returns related records defined relations depending on the method name
+ *
+ * @param string $modelName
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ protected function _getRelatedRecords($modelName, $method, $arguments) {}
+
+ /**
+ * Handles method calls when a method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+<<<<<<< HEAD
+ public function __call($method, $arguments) {}
+=======
+ public function __call($method, $arguments = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Handles method calls when a static method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+ public static function __callStatic($method, $arguments = null) {}
+
+ /**
+ * Magic method to assign values to the the model
+ *
+ * @param string $property
+ * @param mixed $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Magic method to get related records using the relation alias as a property
+ *
+ * @param string $property
+ * @return \Phalcon\Mvc\Model\Resultset|\Phalcon\Mvc\Model
+ */
+ public function __get($property) {}
+
+ /**
+ * Magic method to check if a property is a valid relation
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Serializes the object ignoring connections, services, related objects or static properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+ /**
+ * Returns a simple representation of the object that can be used with var_dump
+ *
+ * var_dump($robot->dump());
+ *
+ *
+ * @return array
+ */
+ public function dump() {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r($robot->toArray());
+ *
+ *
+ * @param mixed $columns
+ * @param array $$columns
+ * @return array
+ */
+ public function toArray($columns = null) {}
+
+ /**
+ * Enables/disables options in the ORM
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+ /**
+ * Reset a model instance data
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/ModelInterface.php b/ide/2.0.4/Phalcon/mvc/ModelInterface.php
new file mode 100644
index 000000000..08345be1b
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/ModelInterface.php
@@ -0,0 +1,342 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Returns related records based on defined relations
+ *
+ * @param string $alias
+ * @param array $arguments
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getRelated($alias, $arguments = null);
+
+ /**
+ * Sets the record's snapshot data.
+ * This method is used internally to set snapshot data when the model was set up to keep snapshot data
+ *
+ * @param array $data
+ * @param array $columnMap
+ */
+ public function setSnapshotData($data, $columnMap = null);
+
+ /**
+ * Reset a model instance data
+ */
+ public function reset();
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/ModuleDefinitionInterface.php b/ide/2.0.4/Phalcon/mvc/ModuleDefinitionInterface.php
new file mode 100644
index 000000000..6df77b02c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/ModuleDefinitionInterface.php
@@ -0,0 +1,26 @@
+
+ * $router = new Router();
+ * $router->add(
+ * "/documentation/{chapter}/{name}\.{type:[a-z]+}",
+=======
+ * Phalcon\Mvc\Router is the standard framework router. Routing is the + * process of taking a URI endpoint (that part of the URI which comes after the base URL) and + * decomposing it into parameters to determine which module, controller, and + * action of that controller should receive the request
+ *
+ * $router = new Router();
+ * $router->add(
+ * "/documentation/{chapter}/{name}.{type:[a-z]+}",
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * array(
+ * "controller" => "documentation",
+ * "action" => "show"
+ * )
+ * );
+ * $router->handle();
+ * echo $router->getControllerName();
+ *
+ */
+<<<<<<< HEAD
+class Router implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\RouterInterface, \Phalcon\Events\EventsAwareInterface
+=======
+class Router implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\RouterInterface
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+{
+
+ const URI_SOURCE_GET_URL = 0;
+
+
+ const URI_SOURCE_SERVER_REQUEST_URI = 1;
+
+
+<<<<<<< HEAD
+ const POSITION_FIRST = 0;
+
+
+ const POSITION_LAST = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_eventsManager;
+
+
+=======
+ protected $_dependencyInjector;
+
+
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ protected $_uriSource;
+
+
+ protected $_namespace = null;
+
+
+ protected $_module = null;
+
+
+ protected $_controller = null;
+
+
+ protected $_action = null;
+
+
+ protected $_params;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ protected $_defaultNamespace;
+
+
+ protected $_defaultModule;
+
+
+ protected $_defaultController;
+
+
+ protected $_defaultAction;
+
+
+ protected $_defaultParams;
+
+
+ protected $_removeExtraSlashes;
+
+
+ protected $_notFoundPaths;
+
+
+ /**
+ * Phalcon\Mvc\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+<<<<<<< HEAD
+ * Sets the events manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Get rewrite info. This info is read from $_GET['_url']. This returns '/' if the rewrite information cannot be read
+ *
+ * @return string
+ */
+ public function getRewriteUri() {}
+
+ /**
+ * Sets the URI source. One of the URI_SOURCE_* constants
+ *
+ * $router->setUriSource(Router::URI_SOURCE_SERVER_REQUEST_URI);
+ *
+ *
+ * @param mixed $uriSource
+ * @return RouterInterface
+ */
+ public function setUriSource($uriSource) {}
+
+ /**
+ * Set whether router must remove the extra slashes in the handled routes
+ *
+ * @param bool $remove
+ * @return RouterInterface
+ */
+ public function removeExtraSlashes($remove) {}
+
+ /**
+ * Sets the name of the default namespace
+ *
+ * @param string $namespaceName
+ * @return RouterInterface
+ */
+ public function setDefaultNamespace($namespaceName) {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ * @return RouterInterface
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ * @return RouterInterface
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ * @return RouterInterface
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return RouterInterface
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Returns an array of default parameters
+ *
+ * @return array
+ */
+ public function getDefaults() {}
+
+ /**
+ * Handles routing information received from the rewrite engine
+ *
+ * //Read the info from the rewrite engine
+ * $router->handle();
+ * //Manually passing an URL
+ * $router->handle('/posts/edit/1');
+ *
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Adds a route to the router without any HTTP constraint
+ *
+<<<<<<< HEAD
+ * use Phalcon\Mvc\Router;
+ * $router->add('/about', 'About::index');
+ * $router->add('/about', 'About::index', ['GET', 'POST']);
+ * $router->add('/about', 'About::index', ['GET', 'POST'], Router::POSITION_FIRST);
+=======
+ * $router->add('/about', 'About::index');
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null, $position = Router::POSITION_LAST) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null, $position = null) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null, $position = null) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null, $position = null) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null, $position = null) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null, $position = null) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null, $position = null) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+<<<<<<< HEAD
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null, $position = null) {}
+=======
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Mounts a group of routes in the router
+ *
+ * @param mixed $group
+ * @return RouterInterface
+ */
+ public function mount(\Phalcon\Mvc\Router\GroupInterface $group) {}
+
+ /**
+ * Set a group of paths to be returned when none of the defined routes are matched
+ *
+ * @param mixed $paths
+ * @return RouterInterface
+ */
+ public function notFound($paths) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Returns the processed namespace name
+ *
+ * @return string
+ */
+ public function getNamespaceName() {}
+
+ /**
+ * Returns the processed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns the processed controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Returns the processed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns the processed parameters
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param mixed $id
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteByName($name) {}
+
+ /**
+ * Returns whether controller name should not be mangled
+ *
+ * @return bool
+ */
+ public function isExactControllerName() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/RouterInterface.php b/ide/2.0.4/Phalcon/mvc/RouterInterface.php
new file mode 100644
index 000000000..d649f3afb
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/RouterInterface.php
@@ -0,0 +1,212 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ */
+class Url implements \Phalcon\Mvc\UrlInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_baseUri = null;
+
+
+ protected $_staticBaseUri = null;
+
+
+ protected $_basePath = null;
+
+
+ protected $_router;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a prefix for all the URIs to be generated
+ *
+ * $url->setBaseUri('/invo/');
+ * $url->setBaseUri('/invo/index.php/');
+ *
+ *
+ * @param string $baseUri
+ * @return Url
+ */
+ public function setBaseUri($baseUri) {}
+
+ /**
+ * Sets a prefix for all static URLs generated
+ *
+ * $url->setStaticBaseUri('/invo/');
+ *
+ *
+ * @param string $staticBaseUri
+ * @return Url
+ */
+ public function setStaticBaseUri($staticBaseUri) {}
+
+ /**
+ * Returns the prefix for all the generated urls. By default /
+ *
+ * @return string
+ */
+ public function getBaseUri() {}
+
+ /**
+ * Returns the prefix for all the generated static urls. By default /
+ *
+ * @return string
+ */
+ public function getStaticBaseUri() {}
+
+ /**
+ * Sets a base path for all the generated paths
+ *
+ * $url->setBasePath('/var/www/htdocs/');
+ *
+ *
+ * @param string $basePath
+ * @return Url
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Returns the base path
+ *
+ * @return string
+ */
+ public function getBasePath() {}
+
+ /**
+ * Generates a URL
+ *
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+<<<<<<< HEAD
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2015'));
+ *
+ *
+ * @param mixed $uri
+ * @param mixed $args
+ * @param mixed $local
+ * @param mixed $baseUri
+ * @return string
+ */
+ public function get($uri = null, $args = null, $local = null, $baseUri = null) {}
+
+ /**
+ * Generates a URL for a static resource
+ *
+ * // Generate a URL for a static resource
+ * echo $url->getStatic("img/logo.png");
+ * // Generate a URL for a static predefined route
+ * echo $url->getStatic(array('for' => 'logo-cdn'));
+ *
+ *
+ * @param mixed $uri
+=======
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ *
+ * @param string|array $uri
+ * @param array|object $args Optional arguments to be appended to the query string
+ * @param bool $local
+ * @param bool $$local
+ * @return string
+ */
+ public function get($uri = null, $args = null, $local = null) {}
+
+ /**
+ * Generates a URL for a static resource
+ *
+ * @param string|array $uri
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * @return string
+ */
+ public function getStatic($uri = null) {}
+
+ /**
+ * Generates a local path
+ *
+ * @param string $path
+ * @return string
+ */
+ public function path($path = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/UrlInterface.php b/ide/2.0.4/Phalcon/mvc/UrlInterface.php
new file mode 100644
index 000000000..9d35e888c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/UrlInterface.php
@@ -0,0 +1,59 @@
+
+ * //Setting views directory
+ * $view = new \Phalcon\Mvc\View();
+ * $view->setViewsDir('app/views/');
+ * $view->start();
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->render('posts', 'recent');
+ * $view->finish();
+ * //Printing views output
+ * echo $view->getContent();
+ *
+ */
+class View extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewInterface
+{
+ /**
+ * Render Level: To the main layout
+ */
+ const LEVEL_MAIN_LAYOUT = 5;
+
+ /**
+ * Render Level: Render to the templates "after"
+ */
+ const LEVEL_AFTER_TEMPLATE = 4;
+
+ /**
+ * Render Level: Hasta el layout del controlador
+ */
+ const LEVEL_LAYOUT = 3;
+
+ /**
+ * Render Level: To the templates "before"
+ */
+ const LEVEL_BEFORE_TEMPLATE = 2;
+
+ /**
+ * Render Level: To the action view
+ */
+ const LEVEL_ACTION_VIEW = 1;
+
+ /**
+ * Render Level: No render any view
+ */
+ const LEVEL_NO_RENDER = 0;
+
+ /**
+ * Cache Mode
+ */
+ const CACHE_MODE_NONE = 0;
+
+
+ const CACHE_MODE_INVERSE = 1;
+
+
+ protected $_options;
+
+
+ protected $_basePath = "";
+
+
+ protected $_content = "";
+
+
+ protected $_renderLevel = 5;
+
+
+ protected $_currentRenderLevel = 0;
+
+
+ protected $_disabledLevels;
+
+
+ protected $_viewParams;
+
+
+ protected $_layout;
+
+
+ protected $_layoutsDir = "";
+
+
+ protected $_partialsDir = "";
+
+
+ protected $_viewsDir;
+
+
+ protected $_templatesBefore;
+
+
+ protected $_templatesAfter;
+
+
+ protected $_engines = false;
+
+
+ protected $_registeredEngines;
+
+
+ protected $_mainView = "index";
+
+
+ protected $_controllerName;
+
+
+ protected $_actionName;
+
+
+ protected $_params;
+
+
+ protected $_pickView;
+
+
+ protected $_cache;
+
+
+ protected $_cacheLevel = 0;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_disabled = false;
+
+
+
+ public function getRenderLevel() {}
+
+
+ public function getCurrentRenderLevel() {}
+
+
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ * @return View
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setLayoutsDir('../common/layouts/');
+ *
+ *
+ * @param string $layoutsDir
+ * @return View
+ */
+ public function setLayoutsDir($layoutsDir) {}
+
+ /**
+ * Gets the current layouts sub-directory
+ *
+ * @return string
+ */
+ public function getLayoutsDir() {}
+
+ /**
+ * Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setPartialsDir('../common/partials/');
+ *
+ *
+ * @param string $partialsDir
+ * @return View
+ */
+ public function setPartialsDir($partialsDir) {}
+
+ /**
+ * Gets the current partials sub-directory
+ *
+ * @return string
+ */
+ public function getPartialsDir() {}
+
+ /**
+ * Sets base path. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setBasePath(__DIR__ . '/');
+ *
+ *
+ * @param string $basePath
+ * @return View
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Sets the render level for the view
+ *
+ * //Render the view related to the controller only
+ * $this->view->setRenderLevel(View::LEVEL_VIEW);
+ *
+ *
+ * @param int $level
+ * @return View
+ */
+ public function setRenderLevel($level) {}
+
+ /**
+ * Disables a specific level of rendering
+ *
+ * //Render all levels except ACTION level
+ * $this->view->disableLevel(View::LEVEL_ACTION_VIEW);
+ *
+ *
+ * @param int|array $level
+ * @return \Phalcon\Mvc\View
+ */
+ public function disableLevel($level) {}
+
+ /**
+ * Sets default view name. Must be a file without extension in the views directory
+ *
+ * //Renders as main view views-dir/base.phtml
+ * $this->view->setMainView('base');
+ *
+ *
+ * @param string $viewPath
+ * @return View
+ */
+ public function setMainView($viewPath) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getMainView() {}
+
+ /**
+ * Change the layout to be used instead of using the name of the latest controller name
+ *
+ * $this->view->setLayout('main');
+ *
+ *
+ * @param string $layout
+ * @return View
+ */
+ public function setLayout($layout) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getLayout() {}
+
+ /**
+ * Sets a template before the controller layout
+ *
+ * @param string|array $templateBefore
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateBefore($templateBefore) {}
+
+ /**
+ * Resets any "template before" layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateBefore() {}
+
+ /**
+ * Sets a "template after" controller layout
+ *
+ * @param string|array $templateAfter
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateAfter($templateAfter) {}
+
+ /**
+ * Resets any template before layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateAfter() {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param boolean $merge
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Gets the name of the controller rendered
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets the name of the action rendered
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Gets extra parameters of the action rendered
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Starts rendering process enabling the output buffering
+ *
+ * @return View
+ */
+ public function start() {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Checks whether view exists on registered extensions and render it
+ *
+ * @param array $engines
+ * @param string $viewPath
+ * @param boolean $silence
+ * @param boolean $mustClean
+ * @param mixed $cache
+ * @param \Phalcon\Cache\BackendInterface $$cache
+ */
+ protected function _engineRender($engines, $viewPath, $silence, $mustClean, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ * @return View
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Checks whether view exists
+ *
+ * @param string $view
+ * @return bool
+ */
+ public function exists($view) {}
+
+ /**
+ * Executes render process from dispatching data
+ *
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->start()->render('posts', 'recent')->finish();
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @return bool|View
+ */
+ public function render($controllerName, $actionName, $params = null) {}
+
+ /**
+ * Choose a different view to render instead of last-controller/last-action
+ *
+ * class ProductsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function saveAction()
+ * {
+ * //Do some save stuff...
+ * //Then show the list view
+ * $this->view->pick("products/list");
+ * }
+ * }
+ *
+ *
+ * @param string|array $renderView
+ * @return \Phalcon\Mvc\View
+ */
+ public function pick($renderView) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Retrieve the contents of a partial
+ * echo $this->getPartial('shared/footer');
+ *
+ *
+ * //Retrieve the contents of a partial with arguments
+ * echo $this->getPartial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ * @return string
+ */
+ public function getPartial($partialPath, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Perform the automatic rendering returning the output as a string
+ *
+ * $template = $this->view->getRender('products', 'show', array('products' => $products));
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @param mixed $configCallback
+ * @return string
+ */
+ public function getRender($controllerName, $actionName, $params = null, $configCallback = null) {}
+
+ /**
+ * Finishes the render process by stopping the output buffering
+ *
+ * @return View
+ */
+ public function finish() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Check if the component is currently caching the output content
+ *
+ * @return bool
+ */
+ public function isCaching() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param boolean|array $options
+ * @return \Phalcon\Mvc\View
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return View
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Disables the auto-rendering process
+ *
+ * @return View
+ */
+ public function disable() {}
+
+ /**
+ * Enables the auto-rendering process
+ *
+ * @return View
+ */
+ public function enable() {}
+
+ /**
+ * Resets the view component to its factory default values
+ *
+ * @return View
+ */
+ public function reset() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+ /**
+ * Whether automatic rendering is enabled
+ *
+ * @return bool
+ */
+ public function isDisabled() {}
+
+ /**
+ * Magic method to retrieve if a variable is set in the view
+ *
+ * echo isset($this->view->products);
+ *
+ *
+ * @param string $key
+ * @return boolean
+ */
+ public function __isset($key) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/ViewBaseInterface.php b/ide/2.0.4/Phalcon/mvc/ViewBaseInterface.php
new file mode 100644
index 000000000..83ad9a96b
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/ViewBaseInterface.php
@@ -0,0 +1,89 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/mvc/ViewInterface.php b/ide/2.0.4/Phalcon/mvc/ViewInterface.php
new file mode 100644
index 000000000..247d28e6e
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/ViewInterface.php
@@ -0,0 +1,200 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Finishes the render process by stopping the output buffering
+ */
+ public function finish();
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath();
+
+ /**
+ * Disables the auto-rendering process
+ */
+ public function disable();
+
+ /**
+ * Enables the auto-rendering process
+ */
+ public function enable();
+
+ /**
+ * Resets the view component to its factory default values
+ */
+ public function reset();
+
+ /**
+ * Whether the automatic rendering is disabled
+ *
+ * @return bool
+ */
+ public function isDisabled();
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/application/Exception.php b/ide/2.0.4/Phalcon/mvc/application/Exception.php
new file mode 100644
index 000000000..d80f7fd7a
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/application/Exception.php
@@ -0,0 +1,12 @@
+x or array[x].
+ */
+<<<<<<< HEAD
+class Document implements \Phalcon\Mvc\EntityInterface, \ArrayAccess
+=======
+class Document implements \ArrayAccess
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+{
+
+ /**
+ * Checks whether an offset exists in the document
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Returns the value of a field using the ArrayAccess interfase
+ *
+ * @param string $index
+<<<<<<< HEAD
+=======
+ * @return mixed
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Change a value using the ArrayAccess interface
+ *
+ * @param string $index
+<<<<<<< HEAD
+ * @param mixed $value
+=======
+ * @param \Phalcon\Mvc\ModelInterface $value
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+<<<<<<< HEAD
+ * echo $robot->readAttribute('name');
+=======
+ * echo robot->readAttribute('name');
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+<<<<<<< HEAD
+ * $robot->writeAttribute('name', 'Rosey');
+=======
+ * robot->writeAttribute('name', 'Rosey');
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+<<<<<<< HEAD
+ /**
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+}
diff --git a/ide/2.0.4/Phalcon/mvc/collection/Exception.php b/ide/2.0.4/Phalcon/mvc/collection/Exception.php
new file mode 100644
index 000000000..736016ca9
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/collection/Exception.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $di->set('collectionManager', function(){
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized;
+
+
+ protected $_lastInitialized;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_connectionServices;
+
+
+ protected $_implicitObjectsIds;
+
+
+ protected $_behaviors;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService) {}
+
+ /**
+ * Sets whether a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds) {}
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Mongo
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ * @return bool
+ */
+ public function missingMethod(\Phalcon\Mvc\CollectionInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/collection/ManagerInterface.php b/ide/2.0.4/Phalcon/mvc/collection/ManagerInterface.php
new file mode 100644
index 000000000..2171a742d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/collection/ManagerInterface.php
@@ -0,0 +1,119 @@
+
+ * $di = new \Phalcon\Di();
+<<<<<<< HEAD
+ * $di->set('collectionManager', function() {
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * $robot = new Robots(di);
+=======
+ * $di->set('collectionManager', function(){
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * robot = new Robots(di);
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ */
+interface ManagerInterface
+{
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager);
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName);
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized();
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService);
+
+ /**
+ * Sets if a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds);
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Returns the connection related to a model
+ *
+<<<<<<< HEAD
+ * @param mixed $model
+=======
+ * @param \Phalcon\Mvc\CollectionInterface $model
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Binds a behavior to a collection
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior);
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/collection/behavior/SoftDelete.php b/ide/2.0.4/Phalcon/mvc/collection/behavior/SoftDelete.php
new file mode 100644
index 000000000..527ee606b
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/collection/behavior/SoftDelete.php
@@ -0,0 +1,21 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $collection = new Collection();
+ * $collection->setHandler(new PostsController());
+ * $collection->get('/posts/edit/{id}', 'edit');
+ * $app->mount($collection);
+ *
+ */
+class Collection implements \Phalcon\Mvc\Micro\CollectionInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_lazy;
+
+
+ protected $_handler;
+
+
+ protected $_handlers;
+
+
+ /**
+ * Internal function to add a handler to the group
+ *
+ * @param string|array $method
+ * @param string $routePattern
+ * @param mixed $handler
+ * @param string $name
+ */
+ protected function _addMap($method, $routePattern, $handler, $name) {}
+
+ /**
+ * Sets a prefix for all routes added to the collection
+ *
+ * @param string $prefix
+ * @return Collection
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the collection prefix if any
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Returns the registered handlers
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+ /**
+ * Sets the main handler
+ *
+ * @param mixed $handler
+ * @param boolean $lazy
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function setHandler($handler, $lazy = false) {}
+
+ /**
+ * Sets if the main handler must be lazy loaded
+ *
+ * @param bool $lazy
+ * @return Collection
+ */
+ public function setLazy($lazy) {}
+
+ /**
+ * Returns if the main handler must be lazy loaded
+ *
+ * @return bool
+ */
+ public function isLazy() {}
+
+ /**
+ * Returns the main handler
+ *
+ * @return mixed
+ */
+ public function getHandler() {}
+
+ /**
+ * Maps a route to a handler
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function map($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is GET
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function get($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is POST
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function post($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PUT
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function put($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PATCH
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function patch($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is HEAD
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function head($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is DELETE
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function delete($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is OPTIONS
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param mixed $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function options($routePattern, $handler, $name = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/micro/CollectionInterface.php b/ide/2.0.4/Phalcon/mvc/micro/CollectionInterface.php
new file mode 100644
index 000000000..30c219445
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/micro/CollectionInterface.php
@@ -0,0 +1,145 @@
+
+ * $robots = Robots::query()
+ * ->where("type = :type:")
+ * ->andWhere("year < 2000")
+ * ->bind(array("type" => "mechanical"))
+ * ->limit(5, 10)
+ * ->orderBy("name")
+ * ->execute();
+ *
+ */
+class Criteria implements \Phalcon\Mvc\Model\CriteriaInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_model;
+
+
+ protected $_params;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return null|\Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set a model on which the query will be executed
+ *
+ * @param string $modelName
+ * @return Criteria
+ */
+ public function setModelName($modelName) {}
+
+ /**
+ * Returns an internal model name on which the criteria will be applied
+ *
+ * @return string
+ */
+ public function getModelName() {}
+
+ /**
+ * Sets the bound parameters in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindParams
+ * @return Criteria
+ */
+ public function bind($bindParams) {}
+
+ /**
+ * Sets the bind types in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindTypes
+ * @return Criteria
+ */
+ public function bindTypes($bindTypes) {}
+
+ /**
+<<<<<<< HEAD
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param mixed $distinct
+ * @return Criteria
+ */
+ public function distinct($distinct) {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Sets the columns to be queried
+ *
+ * $criteria->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function columns($columns) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->join('Robots');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'LEFT');
+ *
+ *
+ * @param string $model
+<<<<<<< HEAD
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @param mixed $type
+ * @return Criteria
+=======
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->innerJoin('Robots');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+<<<<<<< HEAD
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+=======
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $criteria->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+<<<<<<< HEAD
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+=======
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $criteria->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+<<<<<<< HEAD
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+=======
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the conditions parameter in the criteria
+ *
+ * @param string $conditions
+<<<<<<< HEAD
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+=======
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator (deprecated)
+ *
+ * @deprecated 1.0.0
+ * @see \Phalcon\Mvc\Model\Criteria::andWhere()
+ * @param string $conditions
+<<<<<<< HEAD
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+=======
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator
+ *
+ * @param string $conditions
+<<<<<<< HEAD
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+=======
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an OR operator
+ *
+ * @param string $conditions
+<<<<<<< HEAD
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+=======
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+<<<<<<< HEAD
+ * @return Criteria
+=======
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+<<<<<<< HEAD
+ * @return Criteria
+=======
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Adds the conditions parameter to the criteria
+ *
+ * @param string $conditions
+ * @return Criteria
+ */
+ public function conditions($conditions) {}
+
+ /**
+ * Adds the order-by parameter to the criteria (deprecated)
+ *
+ * @deprecated 1.2.1
+ * @see \Phalcon\Mvc\Model\Criteria::orderBy()
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function order($orderColumns) {}
+
+ /**
+<<<<<<< HEAD
+ * Adds the order-by clause to the criteria
+=======
+ * Adds the order-by parameter to the criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function orderBy($orderColumns) {}
+
+ /**
+<<<<<<< HEAD
+ * Adds the group-by clause to the criteria
+ *
+ * @param mixed $group
+ * @return Criteria
+ */
+ public function groupBy($group) {}
+
+ /**
+ * Adds the having clause to the criteria
+ *
+ * @param mixed $having
+ * @return Criteria
+ */
+ public function having($having) {}
+
+ /**
+ * Adds the limit parameter to the criteria
+ *
+ * @param mixed $limit
+ * @param mixed $offset
+ * @return Criteria
+=======
+ * Adds the limit parameter to the criteria
+ *
+ * @param int $limit
+ * @param int $offset
+ * @return \Phalcon\Mvc\Model\Criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function limit($limit, $offset = null) {}
+
+ /**
+ * Adds the "for_update" parameter to the criteria
+ *
+ * @param bool $forUpdate
+ * @return Criteria
+ */
+ public function forUpdate($forUpdate = true) {}
+
+ /**
+ * Adds the "shared_lock" parameter to the criteria
+ *
+ * @param bool $sharedLock
+ * @return Criteria
+ */
+ public function sharedLock($sharedLock = true) {}
+
+ /**
+ * Sets the cache options in the criteria
+ * This method replaces all previously set cache options
+ *
+ * @param array $cache
+ * @return Criteria
+ */
+ public function cache($cache) {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere() {}
+
+ /**
+ * Returns the columns to be queried
+ *
+ * @return string|array|null
+ */
+ public function getColumns() {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions() {}
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit() {}
+
+ /**
+<<<<<<< HEAD
+ * Returns the order clause in the criteria
+=======
+ * Returns the order parameter in the criteria
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ * @return string|null
+ */
+ public function getOrder() {}
+
+ /**
+<<<<<<< HEAD
+ * Returns the group clause in the criteria
+ */
+ public function getGroupBy() {}
+
+ /**
+ * Returns the having clause in the criteria
+ */
+ public function getHaving() {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return Criteria
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data) {}
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function execute() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/CriteriaInterface.php b/ide/2.0.4/Phalcon/mvc/model/CriteriaInterface.php
new file mode 100644
index 000000000..495a337b3
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/CriteriaInterface.php
@@ -0,0 +1,219 @@
+
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function betweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function inWhere($expr, $values);
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function notInWhere($expr, $values);
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere();
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions();
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit();
+
+ /**
+ * Returns the order parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getOrder();
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams();
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return CriteriaInterface
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data);
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return ResultsetInterface
+ */
+ public function execute();
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/Exception.php b/ide/2.0.4/Phalcon/mvc/model/Exception.php
new file mode 100644
index 000000000..1685da6d4
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/Exception.php
@@ -0,0 +1,12 @@
+
+<<<<<<< HEAD
+ * use Phalcon\DI;
+ * use Phalcon\Mvc\Model\Manager as ModelsManager;
+ * $di = new DI();
+ * $di->set('modelsManager', function() {
+ * return new ModelsManager();
+=======
+ * $di = new \Phalcon\DI();
+ * $di->set('modelsManager', function() {
+ * return new \Phalcon\Mvc\Model\Manager();
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\ManagerInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_readConnectionServices;
+
+
+ protected $_writeConnectionServices;
+
+
+ protected $_aliases;
+
+ /**
+ * Has many relations
+ */
+ protected $_hasMany;
+
+ /**
+ * Has many relations by model
+ */
+ protected $_hasManySingle;
+
+ /**
+ * Has one relations
+ */
+ protected $_hasOne;
+
+ /**
+ * Has one relations by model
+ */
+ protected $_hasOneSingle;
+
+ /**
+ * Belongs to relations
+ */
+ protected $_belongsTo;
+
+ /**
+ * All the relationships by model
+ */
+ protected $_belongsToSingle;
+
+ /**
+ * Has many-Through relations
+ */
+ protected $_hasManyToMany;
+
+ /**
+ * Has many-Through relations by model
+ */
+ protected $_hasManyToManySingle;
+
+ /**
+ * Mark initialized models
+ */
+ protected $_initialized;
+
+
+ protected $_sources;
+
+
+ protected $_schemas;
+
+ /**
+ * Models' behaviors
+ */
+ protected $_behaviors;
+
+ /**
+ * Last model initialized
+ */
+ protected $_lastInitialized;
+
+ /**
+ * Last query created/executed
+ */
+ protected $_lastQuery;
+
+ /**
+ * Stores a list of reusable instances
+ */
+ protected $_reusable;
+
+
+ protected $_keepSnapshots;
+
+ /**
+ * Does the model use dynamic update, instead of updating all rows?
+ */
+ protected $_dynamicUpdate;
+
+
+ protected $_namespaceAliases;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a global events manager
+ *
+ * @param mixed $eventsManager
+ * @return Manager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return bool|\Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Initializes a model in the model manager
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function initialize(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get last initialized model
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Loads a model throwing an exception if it doesn't exist
+ *
+ * @param string $modelName
+ * @param bool $newInstance
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function load($modelName, $newInstance = false) {}
+
+ /**
+ * Sets the mapped source for a model
+ *
+ * @param mixed $model
+ * @param string $source
+ */
+ public function setModelSource(\Phalcon\Mvc\ModelInterface $model, $source) {}
+
+ /**
+ * Returns the mapped source for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSource(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets the mapped schema for a model
+ *
+ * @param mixed $model
+ * @param string $schema
+ */
+ public function setModelSchema(\Phalcon\Mvc\ModelInterface $model, $schema) {}
+
+ /**
+ * Returns the mapped schema for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSchema(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets both write and read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets write connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setWriteConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setReadConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Returns the connection to read data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to write data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to read or write data related to a model depending on the connection services.
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ protected function _getConnection(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Returns the connection service name used to read data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getReadConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to write data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getWriteConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to read or write data related to a model depending on the connection services
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return string
+ */
+ public function _getConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ */
+ public function missingMethod(\Phalcon\Mvc\ModelInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if a model must keep snapshots
+ *
+ * @param mixed $model
+ * @param bool $keepSnapshots
+ */
+ public function keepSnapshots(\Phalcon\Mvc\ModelInterface $model, $keepSnapshots) {}
+
+ /**
+ * Checks if a model is keeping snapshots for the queried records
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isKeepingSnapshots(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * @param mixed $model
+ * @param bool $dynamicUpdate
+ */
+ public function useDynamicUpdate(\Phalcon\Mvc\ModelInterface $model, $dynamicUpdate) {}
+
+ /**
+ * Checks if a model is using dynamic update instead of all-field update
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingDynamicUpdate(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasOne(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse many to one between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addBelongsTo(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasMany(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a relation n-m between two models
+ *
+ * @param string fields
+ * @param string intermediateModel
+ * @param string intermediateFields
+ * @param string intermediateReferencedFields
+ * @param string referencedModel
+ * @param string referencedFields
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param array $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasManyToMany(\Phalcon\Mvc\ModelInterface $model, $fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Checks whether a model has a belongsTo relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsBelongsTo($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasMany($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasOne relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasOne($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasManyToMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasManyToMany($modelName, $modelRelation) {}
+
+ /**
+ * Returns a relation by its alias
+ *
+ * @param string $modelName
+ * @param string $alias
+ * @return bool|\Phalcon\Mvc\Model\Relation
+ */
+ public function getRelationByAlias($modelName, $alias) {}
+
+ /**
+<<<<<<< HEAD
+ * Merge two arrays of find parameters
+ *
+ * @param mixed $findParamsOne
+ * @param mixed $findParamsTwo
+ * @return array
+ */
+ protected final function _mergeFindParameters($findParamsOne, $findParamsTwo) {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Helper method to query records based on a relation definition
+ *
+ * @param mixed $relation
+ * @param string $method
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return \Phalcon\Mvc\Model\Resultset\Simple|\Phalcon\Mvc\Model\Resultset\Simple|false
+ */
+ public function getRelationRecords(\Phalcon\Mvc\Model\RelationInterface $relation, $method, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Returns a reusable object from the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ */
+ public function getReusableRecords($modelName, $key) {}
+
+ /**
+ * Stores a reusable record in the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ * @param mixed $records
+ */
+ public function setReusableRecords($modelName, $key, $records) {}
+
+ /**
+ * Clears the internal reusable list
+ */
+ public function clearReusableObjects() {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getBelongsToRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets hasMany related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getHasManyRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getHasOneRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets all the belongsTo relations defined in a model
+ *
+ * $relations = $modelsManager->getBelongsTo(new Robots());
+ *
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getBelongsTo(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getHasOne(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasManyToMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasManyToMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasOneAndHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Query all the relationships defined on a model
+ *
+ * @param string $modelName
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelations($modelName) {}
+
+ /**
+ * Query the first relationship defined between two models
+ *
+ * @param string $first
+ * @param string $second
+ * @return bool|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelationsBetween($first, $second) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query without execute it
+ *
+ * @param string $phql
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function createQuery($phql) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query and execute it
+ *
+ * @param string $phql
+ * @param mixed $placeholders
+ * @param mixed $types
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function executeQuery($phql, $placeholders = null, $types = null) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query\Builder
+ *
+ * @param mixed $params
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function createBuilder($params = null) {}
+
+ /**
+ * Returns the lastest query created or executed in the models manager
+ *
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function getLastQuery() {}
+
+ /**
+ * Registers shorter aliases for namespaces in PHQL statements
+ *
+ * @param string $alias
+ * @param string $namespaceName
+ */
+ public function registerNamespaceAlias($alias, $namespaceName) {}
+
+ /**
+ * Returns a real namespace from its alias
+ *
+ * @param string $alias
+ * @return string
+ */
+ public function getNamespaceAlias($alias) {}
+
+ /**
+ * Returns all the registered namespace aliases
+ *
+ * @return array
+ */
+ public function getNamespaceAliases() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/ManagerInterface.php b/ide/2.0.4/Phalcon/mvc/model/ManagerInterface.php
new file mode 100644
index 000000000..3ef43fb12
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/ManagerInterface.php
@@ -0,0 +1,366 @@
+
+ * use Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if (this->name == 'Peter') {
+ * text = "A robot cannot be named Peter";
+ * field = "name";
+ * type = "InvalidValue";
+ * message = new Message(text, field, type);
+ * this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ */
+class Message implements \Phalcon\Mvc\Model\MessageInterface
+{
+
+ protected $_type;
+
+
+ protected $_message;
+
+
+ protected $_field;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Message constructor
+ *
+ * @param string $message
+ * @param string|array $field
+ * @param string $type
+ * @param \Phalcon\Mvc\ModelInterface $model
+ */
+ public function __construct($message, $field = null, $type = null, $model = null) {}
+
+ /**
+ * Sets message type
+ *
+ * @param string $type
+ * @return Message
+ */
+ public function setType($type) {}
+
+ /**
+ * Returns message type
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Sets verbose message
+ *
+ * @param string $message
+ * @return Message
+ */
+ public function setMessage($message) {}
+
+ /**
+ * Returns verbose message
+ *
+ * @return string
+ */
+ public function getMessage() {}
+
+ /**
+ * Sets field name related to message
+ *
+ * @param mixed $field
+ * @return Message
+ */
+ public function setField($field) {}
+
+ /**
+ * Returns field name related to message
+ */
+ public function getField() {}
+
+ /**
+ * Set the model who generates the message
+ *
+ * @param mixed $model
+ * @return Message
+ */
+ public function setModel(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the model that produced the message
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Magic __toString method returns verbose message
+ *
+ * @return string
+ */
+ public function __toString() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable exporting
+ *
+ * @param array $message
+ * @return Message
+ */
+ public static function __set_state($message) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/MessageInterface.php b/ide/2.0.4/Phalcon/mvc/model/MessageInterface.php
new file mode 100644
index 000000000..e192339b2
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/MessageInterface.php
@@ -0,0 +1,78 @@
+Because Phalcon\Mvc\Model requires meta-data like field names, data types, primary keys, etc.
+ * this component collect them and store for further querying by Phalcon\Mvc\Model.
+ * Phalcon\Mvc\Model\MetaData can also use adapters to store temporarily or permanently the meta-data.
+ * A standard Phalcon\Mvc\Model\MetaData can be used to query model attributes:
+ *
+ * $metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
+ * $attributes = $metaData->getAttributes(new Robots());
+ * print_r($attributes);
+ *
+ */
+abstract class MetaData implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const MODELS_ATTRIBUTES = 0;
+
+
+ const MODELS_PRIMARY_KEY = 1;
+
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+
+ const MODELS_NOT_NULL = 3;
+
+
+ const MODELS_DATA_TYPES = 4;
+
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+
+ const MODELS_DATE_AT = 6;
+
+
+ const MODELS_DATE_IN = 7;
+
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+
+ const MODELS_EMPTY_STRING_VALUES = 13;
+
+
+ const MODELS_COLUMN_MAP = 0;
+
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_strategy;
+
+
+ protected $_metaData;
+
+
+ protected $_columnMap;
+
+
+ /**
+ * Initialize the metadata for certain table
+ *
+ * @param mixed $model
+ * @param mixed $key
+ * @param mixed $table
+ * @param mixed $schema
+ */
+ protected final function _initialize(\Phalcon\Mvc\ModelInterface $model, $key, $table, $schema) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set the meta-data extraction strategy
+ *
+ * @param mixed $strategy
+ */
+ public function setStrategy(\Phalcon\Mvc\Model\MetaData\StrategyInterface $strategy) {}
+
+ /**
+ * Return the strategy to obtain the meta-data
+ *
+ * @return \Phalcon\Mvc\Model\MetaData\StrategyInterface
+ */
+ public function getStrategy() {}
+
+ /**
+ * Reads the complete meta-data for certain model
+ *
+ * print_r($metaData->readMetaData(new Robots());
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readMetaData(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads meta-data for certain model
+ *
+ * print_r($metaData->readMetaDataIndex(new Robots(), 0);
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Writes meta-data for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ * @param mixed $data
+ */
+ public final function writeMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index, $data) {}
+
+ /**
+ * Reads the ordered/reversed column map for certain model
+ *
+ * print_r($metaData->readColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads column-map information for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->readColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readColumnMapIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Returns table attributes names (fields)
+ *
+ * print_r($metaData->getAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are part of the primary key
+ *
+ * print_r($metaData->getPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are not part of the primary key
+ *
+ * print_r($metaData->getNonPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNonPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of not null attributes
+ *
+ * print_r($metaData->getNotNullAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNotNullAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their data types
+ *
+ * print_r($metaData->getDataTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes which types are numerical
+ *
+ * print_r($metaData->getDataTypesNumeric(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypesNumeric(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the name of identity field (if one is present)
+ *
+ * print_r($metaData->getIdentityField(new Robots()));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @return string
+ */
+ public function getIdentityField(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their bind data types
+ *
+ * print_r($metaData->getBindTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getBindTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the INSERT SQL generation
+ *
+ * print_r($metaData->getAutomaticCreateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the UPDATE SQL generation
+ *
+ * print_r($metaData->getAutomaticUpdateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Set the attributes that must be ignored from the INSERT SQL generation
+ *
+ * $metaData->setAutomaticCreateAttributes(new Robots(), array('created_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that must be ignored from the UPDATE SQL generation
+ *
+ * $metaData->setAutomaticUpdateAttributes(new Robots(), array('modified_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that allow empty string values
+ *
+ * $metaData->setEmptyStringAttributes(new Robots(), array('name' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Returns attributes allow empty strings
+ *
+ * print_r($metaData->getEmptyStringAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes (which have default values) and their default values
+ *
+ * print_r($metaData->getDefaultValues(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDefaultValues(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the column map if any
+ *
+ * print_r($metaData->getColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the reverse column map if any
+ *
+ * print_r($metaData->getReverseColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getReverseColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check if a model has certain attribute
+ *
+ * var_dump($metaData->hasAttribute(new Robots(), 'name'));
+ *
+ *
+ * @param mixed $model
+ * @param string $attribute
+ * @return bool
+ */
+ public function hasAttribute(\Phalcon\Mvc\ModelInterface $model, $attribute) {}
+
+ /**
+ * Checks if the internal meta-data container is empty
+ *
+ * var_dump($metaData->isEmpty());
+ *
+ *
+ * @return bool
+ */
+ public function isEmpty() {}
+
+ /**
+ * Resets internal meta-data in order to regenerate it
+ *
+ * $metaData->reset();
+ *
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/MetaDataInterface.php b/ide/2.0.4/Phalcon/mvc/model/MetaDataInterface.php
new file mode 100644
index 000000000..930c326a7
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/MetaDataInterface.php
@@ -0,0 +1,241 @@
+
+ * $phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
+ * WHERE b.name = :name: ORDER BY c.name";
+ * $result = manager->executeQuery($phql, array(
+ * "name": "Lamborghini"
+ * ));
+ * foreach ($result as $row) {
+<<<<<<< HEAD
+ * echo "Name: ", $row->cars->name, "\n";
+=======
+ * echo "Name: ", $row->cars->name, "\n";
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * echo "Price: ", $row->cars->price, "\n";
+ * echo "Taxes: ", $row->taxes, "\n";
+ * }
+ *
+ */
+class Query implements \Phalcon\Mvc\Model\QueryInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ const TYPE_SELECT = 309;
+
+
+ const TYPE_INSERT = 306;
+
+
+ const TYPE_UPDATE = 300;
+
+
+ const TYPE_DELETE = 303;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_manager;
+
+
+ protected $_metaData;
+
+
+ protected $_type;
+
+
+ protected $_phql;
+
+
+ protected $_ast;
+
+
+ protected $_intermediate;
+
+
+ protected $_models;
+
+
+ protected $_sqlAliases;
+
+
+ protected $_sqlAliasesModels;
+
+
+ protected $_sqlModelsAliases;
+
+
+ protected $_sqlAliasesModelsInstances;
+
+
+ protected $_sqlColumnAliases;
+
+
+ protected $_modelsInstances;
+
+
+ protected $_cache;
+
+
+ protected $_cacheOptions;
+
+
+ protected $_uniqueRow;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ static protected $_irPhqlCache;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query constructor
+ *
+ * @param string $phql
+ * @param \Phalcon\DiInterface $dependencyInjector
+ */
+ public function __construct($phql = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Tells to the query if only the first row in the resultset must be returned
+ *
+ * @param bool $uniqueRow
+ * @return Query
+ */
+ public function setUniqueRow($uniqueRow) {}
+
+ /**
+ * Check if the query is programmed to get only the first row in the resultset
+ *
+ * @return bool
+ */
+ public function getUniqueRow() {}
+
+ /**
+ * Replaces the model's name to its source name in a qualifed-name expression
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getQualified($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $argument
+ * @return array
+ */
+ protected final function _getCallArgument($argument) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getCaseExpression($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getFunctionCall($expr) {}
+
+ /**
+ * Resolves an expression from its intermediate code into a string
+ *
+ * @param array $expr
+ * @param boolean $quoting
+ * @return string
+ */
+ protected final function _getExpression($expr, $quoting = true) {}
+
+ /**
+ * Resolves a column from its intermediate representation into an array used to determine
+ * if the resultset produced is simple or complex
+ *
+ * @param array $column
+ * @return array
+ */
+ protected final function _getSelectColumn($column) {}
+
+ /**
+ * Resolves a table in a SELECT statement checking if the model exists
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $qualifiedName
+ * @return string
+ */
+ protected final function _getTable(\Phalcon\Mvc\Model\ManagerInterface $manager, $qualifiedName) {}
+
+ /**
+ * Resolves a JOIN clause checking if the associated models exist
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $join
+ * @return array
+ */
+ protected final function _getJoin(\Phalcon\Mvc\Model\ManagerInterface $manager, $join) {}
+
+ /**
+ * Resolves a JOIN type
+ *
+ * @param array $join
+ * @return string
+ */
+ protected final function _getJoinType($join) {}
+
+ /**
+ * Resolves joins involving has-one/belongs-to/has-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getSingleJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Resolves joins involving many-to-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getMultiJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Processes the JOINs in the query returning an internal representation for the database dialect
+ *
+ * @param array $select
+ * @return array
+ */
+ protected final function _getJoins($select) {}
+
+ /**
+ * Returns a processed order clause for a SELECT statement
+ *
+ * @param mixed $order
+ * @param array|string $$order
+ * @return array
+ */
+ protected final function _getOrderClause($order) {}
+
+ /**
+ * Returns a processed group clause for a SELECT statement
+ *
+<<<<<<< HEAD
+ * @param array $group
+=======
+ * @param mixed $group
+ * @param array $$group
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * @return array
+ */
+ protected final function _getGroupClause($group) {}
+
+ /**
+ * Returns a processed limit clause for a SELECT statement
+ *
+<<<<<<< HEAD
+ * @param array $limitClause
+=======
+ * @param mixed $limitClause
+ * @param array $$limit
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * @return array
+ */
+ protected final function _getLimitClause($limitClause) {}
+
+ /**
+ * Analyzes a SELECT intermediate code and produces an array to be executed later
+ *
+ * @param mixed $ast
+ * @param mixed $merge
+ * @return array
+ */
+ protected final function _prepareSelect($ast = null, $merge = null) {}
+
+ /**
+ * Analyzes an INSERT intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareInsert() {}
+
+ /**
+ * Analyzes an UPDATE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareUpdate() {}
+
+ /**
+ * Analyzes a DELETE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareDelete() {}
+
+ /**
+ * Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another
+ * intermediate representation that could be executed by Phalcon\Mvc\Model\Query
+ *
+ * @return array
+ */
+ public function parse() {}
+
+ /**
+ * Returns the current cache backend instance
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Executes the SELECT intermediate representation producing a Phalcon\Mvc\Model\Resultset
+ *
+ * @param mixed $intermediate
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @param bool $simulate
+ * @return array|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _executeSelect($intermediate, $bindParams, $bindTypes, $simulate = false) {}
+
+ /**
+ * Executes the INSERT intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeInsert($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the UPDATE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeUpdate($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the DELETE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeDelete($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Query the records on which the UPDATE/DELETE operation well be done
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _getRelatedRecords(\Phalcon\Mvc\ModelInterface $model, $intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes a parsed PHQL statement
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return mixed
+ */
+ public function execute($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Executes the query returning the first result
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return Ṕhalcon\Mvc\ModelInterface
+ */
+ public function getSingleResult($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sets the type of PHQL statement to be executed
+ *
+ * @param int $type
+ * @return Query
+ */
+ public function setType($type) {}
+
+ /**
+ * Gets the type of PHQL statement executed
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindParams
+<<<<<<< HEAD
+ * @param bool $merge
+ * @return Query
+ */
+ public function setBindParams($bindParams, $merge = false) {}
+=======
+ * @return Query
+ */
+ public function setBindParams($bindParams) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Returns default bind params
+ *
+ * @return array
+ */
+ public function getBindParams() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindTypes
+<<<<<<< HEAD
+ * @param bool $merge
+ * @return Query
+ */
+ public function setBindTypes($bindTypes, $merge = false) {}
+=======
+ * @return Query
+ */
+ public function setBindTypes($bindTypes) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Returns default bind types
+ *
+ * @return array
+ */
+ public function getBindTypes() {}
+
+ /**
+ * Allows to set the IR to be executed
+ *
+ * @param array $intermediate
+ * @return Query
+ */
+ public function setIntermediate($intermediate) {}
+
+ /**
+ * Returns the intermediate representation of the PHQL statement
+ *
+ * @return array
+ */
+ public function getIntermediate() {}
+
+ /**
+ * Sets the cache parameters of the query
+ *
+ * @param mixed $cacheOptions
+ * @return Query
+ */
+ public function cache($cacheOptions) {}
+
+ /**
+ * Returns the current cache options
+ *
+ * @param array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
+ *
+ * @return array
+ */
+ public function getSql() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/QueryInterface.php b/ide/2.0.4/Phalcon/mvc/model/QueryInterface.php
new file mode 100644
index 000000000..058d68f18
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/QueryInterface.php
@@ -0,0 +1,59 @@
+
+ * //Using a standard foreach
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ * //Using a while
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * $robots->rewind();
+ * while ($robots->valid()) {
+ * $robot = $robots->current();
+ * echo $robot->name, "\n";
+ * $robots->next();
+ * }
+ *
+ */
+abstract class Resultset implements \Phalcon\Mvc\Model\ResultsetInterface, \Iterator, \SeekableIterator, \Countable, \ArrayAccess, \Serializable
+{
+
+ const TYPE_RESULT_FULL = 0;
+
+
+ const TYPE_RESULT_PARTIAL = 1;
+
+
+ const HYDRATE_RECORDS = 0;
+
+
+ const HYDRATE_OBJECTS = 2;
+
+
+ const HYDRATE_ARRAYS = 1;
+
+ /**
+ * Phalcon\Db\ResultInterface or false for empty resultset
+ */
+ protected $_result = false;
+
+
+ protected $_cache;
+
+
+ protected $_isFresh = true;
+
+
+ protected $_pointer = 0;
+
+
+ protected $_count;
+
+
+ protected $_activeRow = null;
+
+
+ protected $_rows = null;
+
+
+ protected $_row = null;
+
+
+ protected $_errorMessages;
+
+
+ protected $_hydrateMode = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Resultset constructor
+ *
+ * @param \Phalcon\Db\ResultInterface|false $result
+ * @param \Phalcon\Cache\BackendInterface $cache
+ * @param array $columnTypes
+ */
+ public function __construct($result, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Moves cursor to next row in the resultset
+ */
+ public function next() {}
+
+ /**
+ * Check whether internal resource has rows to fetch
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Gets pointer number of active row in the resultset
+ *
+ * @return int|null
+ */
+ public function key() {}
+
+ /**
+ * Rewinds resultset to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Changes internal pointer to a specific position in the resultset
+ * Set new position if required and set this->_row
+ *
+ * @param int $position
+ */
+ public final function seek($position) {}
+
+ /**
+ * Counts how many rows are in the resultset
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Checks whether offset exists in the resultset
+ *
+ * @param int $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets row in a specific position of the resultset
+ *
+ * @param int $index
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Returns the internal type of data retrieval that the resultset is using
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Get first row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getFirst() {}
+
+ /**
+ * Get last row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getLast() {}
+
+ /**
+ * Set if the resultset is fresh or an old one cached
+ *
+ * @param bool $isFresh
+ * @return Resultset
+ */
+ public function setIsFresh($isFresh) {}
+
+ /**
+ * Tell if the resultset if fresh or an old one cached
+ *
+ * @return bool
+ */
+ public function isFresh() {}
+
+ /**
+ * Sets the hydration mode in the resultset
+ *
+ * @param int $hydrateMode
+ * @return Resultset
+ */
+ public function setHydrateMode($hydrateMode) {}
+
+ /**
+ * Returns the current hydration mode
+ *
+ * @return int
+ */
+ public function getHydrateMode() {}
+
+ /**
+ * Returns the associated cache for the resultset
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Returns the error messages produced by a batch operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Updates every record in the resultset
+ *
+ * @param array $data
+ * @param Closure $conditionCallback
+ * @return boolean
+ */
+ public function update($data, \Closure $conditionCallback = null) {}
+
+ /**
+ * Deletes every record in the resultset
+ *
+ * @param mixed $conditionCallback
+ * @return bool
+ */
+ public function delete(\Closure $conditionCallback = null) {}
+
+ /**
+ * Filters a resultset returning only those the developer requires
+ *
+ * $filtered = $robots->filter(function($robot){
+ * if ($robot->id < 3) {
+ * return $robot;
+ * }
+ * });
+ *
+ *
+ * @param callback $filter
+ * @return \Phalcon\Mvc\Model[]
+ */
+ public function filter($filter) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/ResultsetInterface.php b/ide/2.0.4/Phalcon/mvc/model/ResultsetInterface.php
new file mode 100644
index 000000000..58903e36e
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/ResultsetInterface.php
@@ -0,0 +1,62 @@
+x or array[x].
+ */
+<<<<<<< HEAD
+class Row implements \Phalcon\Mvc\EntityInterface, \Phalcon\Mvc\Model\ResultInterface, \ArrayAccess
+=======
+class Row implements \ArrayAccess, \Phalcon\Mvc\Model\ResultInterface
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+{
+
+ /**
+ * Set the current object's state
+ *
+ * @param int $dirtyState
+ * @return bool
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Checks whether offset exists in the row
+ *
+ * @param mixed $index
+ * @param string|int $$index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets a record in a specific position of the row
+ *
+ * @param string|int $index
+ * @return string|Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+<<<<<<< HEAD
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/Transaction.php b/ide/2.0.4/Phalcon/mvc/model/Transaction.php
new file mode 100644
index 000000000..cfc88900d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/Transaction.php
@@ -0,0 +1,146 @@
+
+ * try {
+ * $manager = new \Phalcon\Mvc\Model\Transaction\Manager();
+ * $transaction = $manager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch(Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Transaction implements \Phalcon\Mvc\Model\TransactionInterface
+{
+
+ protected $_connection;
+
+
+ protected $_activeTransaction = false;
+
+
+ protected $_isNewTransaction = true;
+
+
+ protected $_rollbackOnAbort = false;
+
+
+ protected $_manager;
+
+
+ protected $_messages;
+
+
+ protected $_rollbackRecord;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param boolean $autoBegin
+ * @param string $service
+ * @param \Phalcon\DiInterface $$ependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector, $autoBegin = false, $service = null) {}
+
+ /**
+ * Sets transaction manager related to the transaction
+ *
+ * @param mixed $manager
+ */
+ public function setTransactionManager(\Phalcon\Mvc\Model\Transaction\ManagerInterface $manager) {}
+
+ /**
+ * Starts the transaction
+ *
+ * @return bool
+ */
+ public function begin() {}
+
+ /**
+ * Commits the transaction
+ *
+ * @return bool
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks the transaction
+ *
+ * @param string $rollbackMessage
+ * @param \Phalcon\Mvc\ModelInterface $rollbackRecord
+ * @return boolean
+ */
+ public function rollback($rollbackMessage = null, $rollbackRecord = null) {}
+
+ /**
+ * Returns the connection related to transaction
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection() {}
+
+ /**
+ * Sets if is a reused transaction or new once
+ *
+ * @param bool $isNew
+ */
+ public function setIsNewTransaction($isNew) {}
+
+ /**
+ * Sets flag to rollback on abort the HTTP connection
+ *
+ * @param bool $rollbackOnAbort
+ */
+ public function setRollbackOnAbort($rollbackOnAbort) {}
+
+ /**
+ * Checks whether transaction is managed by a transaction manager
+ *
+ * @return bool
+ */
+ public function isManaged() {}
+
+ /**
+ * Returns validations messages from last save try
+ *
+ * @return array
+ */
+ public function getMessages() {}
+
+ /**
+ * Checks whether internal connection is under an active transaction
+ *
+ * @return bool
+ */
+ public function isValid() {}
+
+ /**
+ * Sets object which generates rollback action
+ *
+ * @param mixed $record
+ */
+ public function setRollbackedRecord(\Phalcon\Mvc\ModelInterface $record) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/TransactionInterface.php b/ide/2.0.4/Phalcon/mvc/model/TransactionInterface.php
new file mode 100644
index 000000000..88a500734
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/TransactionInterface.php
@@ -0,0 +1,91 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Returns an option
+ *
+<<<<<<< HEAD
+ * @param string $option
+ * @param mixed $defaultValue
+ * @return variable
+ */
+ public function getOption($option, $defaultValue = "") {}
+=======
+ * @param string option
+ * @return mixed
+ * @param string $option
+ */
+ protected function getOption($option) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Check whether a option has been defined in the validator options
+ *
+ * @param string $option
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function isSetOption($option) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator() {}
+=======
+ protected function isSetOption($option) {}
+
+
+ function zephir_init_properties() {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/ValidatorInterface.php b/ide/2.0.4/Phalcon/mvc/model/ValidatorInterface.php
new file mode 100644
index 000000000..4de575cf9
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/ValidatorInterface.php
@@ -0,0 +1,31 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/behavior/SoftDelete.php b/ide/2.0.4/Phalcon/mvc/model/behavior/SoftDelete.php
new file mode 100644
index 000000000..ee37712d5
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/behavior/SoftDelete.php
@@ -0,0 +1,21 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Apc(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Apc extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from APC
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/metadata/Files.php b/ide/2.0.4/Phalcon/mvc/model/metadata/Files.php
new file mode 100644
index 000000000..86b59be2c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/metadata/Files.php
@@ -0,0 +1,43 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Files(array(
+ * 'metaDataDir' => 'app/cache/metadata/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_metaDataDir = "./";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from files
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to files
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/metadata/Memory.php b/ide/2.0.4/Phalcon/mvc/model/metadata/Memory.php
new file mode 100644
index 000000000..c389c473f
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/metadata/Memory.php
@@ -0,0 +1,35 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Session(array(
+ * 'prefix' => 'my-app-id'
+ * ));
+ *
+ */
+class Session extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Session constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from $_SESSION
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to $_SESSION
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/metadata/StrategyInterface.php b/ide/2.0.4/Phalcon/mvc/model/metadata/StrategyInterface.php
new file mode 100644
index 000000000..b7874be24
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/metadata/StrategyInterface.php
@@ -0,0 +1,28 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Xcache(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Xcache extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Xcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from XCache
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to XCache
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/metadata/strategy/Annotations.php b/ide/2.0.4/Phalcon/mvc/model/metadata/strategy/Annotations.php
new file mode 100644
index 000000000..f1b7b11fa
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/metadata/strategy/Annotations.php
@@ -0,0 +1,27 @@
+
+ * $params = array(
+ * 'models' => array('Users'),
+ * 'columns' => array('id', 'name', 'status'),
+ * 'conditions' => array(
+ * array(
+ * "created > :min: AND created < :max:",
+ * array("min" => '2013-01-01', 'max' => '2014-01-01'),
+ * array("min" => PDO::PARAM_STR, 'max' => PDO::PARAM_STR),
+ * ),
+ * ),
+ * // or 'conditions' => "created > '2013-01-01' AND created < '2014-01-01'",
+ * 'group' => array('id', 'name'),
+ * 'having' => "name = 'Kamil'",
+ * 'order' => array('name', 'id'),
+ * 'limit' => 20,
+ * 'offset' => 20,
+ * // or 'limit' => array(20, 20),
+ * );
+ * $queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);
+ *
+ */
+class Builder implements \Phalcon\Mvc\Model\Query\BuilderInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_columns;
+
+
+ protected $_models;
+
+
+ protected $_joins;
+
+
+ protected $_with;
+
+
+ protected $_conditions;
+
+
+ protected $_group;
+
+
+ protected $_having;
+
+
+ protected $_order;
+
+
+ protected $_limit;
+
+
+ protected $_offset;
+
+
+ protected $_forUpdate;
+
+
+ protected $_sharedLock;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_distinct;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Builder constructor
+ *
+ * @param mixed $params
+ * @param mixed $dependencyInjector
+ */
+ public function __construct($params = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ * @return Builder
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param bool|null $distinct
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function distinct($distinct) {}
+
+ /**
+ * Returns SELECT DISTINCT / SELECT ALL flag
+ *
+ * @return bool
+ */
+ public function getDistinct() {}
+
+ /**
+ * Sets the columns to be queried
+ *
+ * $builder->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function columns($columns) {}
+
+ /**
+ * Return the columns to be queried
+ *
+ * @return string|array
+ */
+ public function getColumns() {}
+
+ /**
+ * Sets the models who makes part of the query
+ *
+ * $builder->from('Robots');
+ * $builder->from(array('Robots', 'RobotsParts'));
+ *
+ *
+ * @param string|array $models
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function from($models) {}
+
+ /**
+ * Add a model to take part of the query
+ *
+ * $builder->addFrom('Robots', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function addFrom($model, $alias = null) {}
+
+ /**
+ * Return the models who makes part of the query
+ *
+ * @return string|array
+ */
+ public function getFrom() {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->join('Robots');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'INNER');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->innerJoin('Robots');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $builder->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $builder->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the query conditions
+ *
+ * $builder->where(100);
+ * $builder->where('name = "Peter"');
+ * $builder->where('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param mixed $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a AND operator
+ *
+ * $builder->andWhere('name = "Peter"');
+ * $builder->andWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a OR operator
+ *
+ * $builder->orWhere('name = "Peter"');
+ * $builder->orWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $builder->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+<<<<<<< HEAD
+ * @return Builder
+=======
+ * @return \Phalcon\Mvc\Model\Query\Builder
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $builder->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+<<<<<<< HEAD
+ * @return Builder
+=======
+ * @return \Phalcon\Mvc\Model\Query\Builder
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $builder->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $builder->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Return the conditions for the query
+ *
+ * @return string|array
+ */
+ public function getWhere() {}
+
+ /**
+ * Sets a ORDER BY condition clause
+ *
+ * $builder->orderBy('Robots.name');
+ * $builder->orderBy(array('1', 'Robots.name'));
+ *
+ *
+ * @param string|array $orderBy
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orderBy($orderBy) {}
+
+ /**
+ * Returns the set ORDER BY clause
+ *
+ * @return string|array
+ */
+ public function getOrderBy() {}
+
+ /**
+ * Sets a HAVING condition clause. You need to escape PHQL reserved words using [ and ] delimiters
+ *
+ * $builder->having('SUM(Robots.price) > 0');
+ *
+ *
+ * @param string $having
+ * @return Builder
+ */
+ public function having($having) {}
+
+ /**
+<<<<<<< HEAD
+ * Sets a FOR UPDATE clause
+ *
+ * $builder->forUpdate(true);
+ *
+ *
+ * @param bool $forUpdate
+ * @return Builder
+ */
+ public function forUpdate($forUpdate) {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Return the current having clause
+ *
+ * @return string|array
+ */
+ public function getHaving() {}
+
+ /**
+ * Sets a LIMIT clause, optionally a offset clause
+ *
+ * $builder->limit(100);
+ * $builder->limit(100, 20);
+ *
+ *
+ * @param int $limit
+ * @param int $offset
+ * @return Builder
+ */
+ public function limit($limit = null, $offset = null) {}
+
+ /**
+ * Returns the current LIMIT clause
+ *
+ * @return string|array
+ */
+ public function getLimit() {}
+
+ /**
+ * Sets an OFFSET clause
+ *
+ * $builder->offset(30);
+ *
+ *
+ * @param int $offset
+ * @return Builder
+ */
+ public function offset($offset) {}
+
+ /**
+ * Returns the current OFFSET clause
+ *
+ * @return string|array
+ */
+ public function getOffset() {}
+
+ /**
+ * Sets a GROUP BY clause
+ *
+ * $builder->groupBy(array('Robots.name'));
+ *
+ *
+ * @param string|array $group
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function groupBy($group) {}
+
+ /**
+ * Returns the GROUP BY clause
+ *
+ * @return string
+ */
+ public function getGroupBy() {}
+
+ /**
+ * Returns a PHQL statement built based on the builder parameters
+ *
+ * @return string
+ */
+ public final function getPhql() {}
+
+ /**
+ * Returns the query built
+ *
+ * @return \Phalcon\Mvc\Model\Query
+ */
+ public function getQuery() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/query/BuilderInterface.php b/ide/2.0.4/Phalcon/mvc/model/query/BuilderInterface.php
new file mode 100644
index 000000000..9e8b04895
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/query/BuilderInterface.php
@@ -0,0 +1,249 @@
+
+ * $intermediate = Phalcon\Mvc\Model\Query\Lang::parsePHQL("SELECT r.* FROM Robots r LIMIT 10");
+ *
+ */
+abstract class Lang
+{
+
+ /**
+ * Parses a PHQL statement returning an intermediate representation (IR)
+ *
+ * @param string $phql
+ * @return string
+ */
+ public static function parsePHQL($phql) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/query/Status.php b/ide/2.0.4/Phalcon/mvc/model/query/Status.php
new file mode 100644
index 000000000..44bd6423d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/query/Status.php
@@ -0,0 +1,63 @@
+
+ * $phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";
+ * $status = $app->modelsManager->executeQuery($phql, array(
+ * 'id' => 100,
+ * 'name' => 'Astroy Boy',
+ * 'type' => 'mechanical',
+ * 'year' => 1959
+ * ));
+ * \//Check if the update was successful
+ * if ($status->success() == true) {
+ * echo 'OK';
+ * }
+ *
+ */
+class Status implements \Phalcon\Mvc\Model\Query\StatusInterface
+{
+
+ protected $_success;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Status
+ *
+ * @param bool $success
+ * @param mixed $model
+ */
+ public function __construct($success, \Phalcon\Mvc\ModelInterface $model = null) {}
+
+ /**
+ * Returns the model that executed the action
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Returns the messages produced because of a failed operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Allows to check if the executed operation was successful
+ *
+ * @return bool
+ */
+ public function success() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/query/StatusInterface.php b/ide/2.0.4/Phalcon/mvc/model/query/StatusInterface.php
new file mode 100644
index 000000000..9b1b58318
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/query/StatusInterface.php
@@ -0,0 +1,41 @@
+
+ * try {
+ * use Phalcon\Mvc\Model\Transaction\Manager as TransactionManager;
+ * $transactionManager = new TransactionManager();
+ * $transaction = $transactionManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if($robot->save()==false){
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if($robotPart->save()==false){
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch (Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\Transaction\ManagerInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized = false;
+
+
+ protected $_rollbackPendent = true;
+
+
+ protected $_number = 0;
+
+
+ protected $_service = "db";
+
+
+ protected $_transactions;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction\Manager constructor
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the database service used to run the isolated transactions
+ *
+ * @param string $service
+ * @return Manager
+ */
+ public function setDbService($service) {}
+
+ /**
+ * Returns the database service used to isolate the transaction
+ *
+ * @return string
+ */
+ public function getDbService() {}
+
+ /**
+ * Set if the transaction manager must register a shutdown function to clean up pendent transactions
+ *
+ * @param bool $rollbackPendent
+ * @return Manager
+ */
+ public function setRollbackPendent($rollbackPendent) {}
+
+ /**
+ * Check if the transaction manager is registering a shutdown function to clean up pendent transactions
+ *
+ * @return bool
+ */
+ public function getRollbackPendent() {}
+
+ /**
+ * Checks whether the manager has an active transaction
+ *
+ * @return bool
+ */
+ public function has() {}
+
+ /**
+ * Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
+ * This method registers a shutdown function to rollback active connections
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function get($autoBegin = true) {}
+
+ /**
+ * Create/Returns a new transaction or an existing one
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function getOrCreateTransaction($autoBegin = true) {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ */
+ public function rollbackPendent() {}
+
+ /**
+ * Commmits active transactions within the manager
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ * Collect will remove the transaction from the manager
+ *
+ * @param boolean $collect
+ */
+ public function rollback($collect = true) {}
+
+ /**
+ * Notifies the manager about a rollbacked transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyRollback(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Notifies the manager about a commited transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyCommit(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Removes transactions from the TransactionManager
+ *
+ * @param mixed $transaction
+ */
+ protected function _collectTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Remove all the transactions from the manager
+ */
+ public function collectTransactions() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/transaction/ManagerInterface.php b/ide/2.0.4/Phalcon/mvc/model/transaction/ManagerInterface.php
new file mode 100644
index 000000000..5fc97d481
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/transaction/ManagerInterface.php
@@ -0,0 +1,71 @@
+
+ * use Phalcon\Mvc\Model\Validator\Email as EmailValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new EmailValidator(array(
+ * 'field' => 'electronic_mail'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Email extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Email() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/Exclusionin.php b/ide/2.0.4/Phalcon/mvc/model/validator/Exclusionin.php
new file mode 100644
index 000000000..b560ace45
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/Exclusionin.php
@@ -0,0 +1,43 @@
+
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionInValidator(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Exclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Exclusionin() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/Inclusionin.php b/ide/2.0.4/Phalcon/mvc/model/validator/Inclusionin.php
new file mode 100644
index 000000000..127458a43
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/Inclusionin.php
@@ -0,0 +1,43 @@
+
+ * use Phalcon\Mvc\Model\Validator\InclusionIn as InclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new InclusionInValidator(array(
+ * "field" => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Inclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Inclusionin() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/Ip.php b/ide/2.0.4/Phalcon/mvc/model/validator/Ip.php
new file mode 100644
index 000000000..d299c5d83
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/Ip.php
@@ -0,0 +1,62 @@
+
+ * use Phalcon\Mvc\Model\Validator\CardNumber;
+ * class Data extends Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * // Any pubic IP
+ * $this->validate(new IPv4(array(
+ * 'field' => 'server_ip',
+ * 'version' => IP::VERSION_4 | IP::VERSION_6, // v6 and v4. The same if not specified
+ * 'allowReserved' => false, // False if not specified. Ignored for v6
+ * 'allowPrivate' => false, // False if not specified
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * // Any public v4 address
+ * $this->validate(new IP(array(
+ * 'field' => 'ip_4',
+ * 'version' => IP::VERSION_4,
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * // Any v6 address
+ * $this->validate(new IP(array(
+ * 'field' => 'ip6',
+ * 'version' => IP::VERSION_6,
+ * 'allowPrivate' => true,
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Ip extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ const VERSION_4 = 1048576;
+
+
+ const VERSION_6 = 2097152;
+
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Ip() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/Numericality.php b/ide/2.0.4/Phalcon/mvc/model/validator/Numericality.php
new file mode 100644
index 000000000..d7cfa805d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/Numericality.php
@@ -0,0 +1,42 @@
+
+ * use Phalcon\Mvc\Model\Validator\Numericality as NumericalityValidator;
+ * class Products extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new NumericalityValidator(array(
+ * "field" => 'price'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Numericality extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Numericality() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/PresenceOf.php b/ide/2.0.4/Phalcon/mvc/model/validator/PresenceOf.php
new file mode 100644
index 000000000..711c68d9b
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/PresenceOf.php
@@ -0,0 +1,43 @@
+
+ * use Phalcon\Mvc\Model\Validator\PresenceOf;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new PresenceOf(array(
+ * "field" => 'name',
+ * "message" => 'The name is required'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class PresenceOf extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_PresenceOf() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/Regex.php b/ide/2.0.4/Phalcon/mvc/model/validator/Regex.php
new file mode 100644
index 000000000..5913287ca
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/Regex.php
@@ -0,0 +1,43 @@
+
+ * use Phalcon\Mvc\Model\Validator\Regex as RegexValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new RegexValidator(array(
+ * "field" => 'created_at',
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])/'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Regex extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Regex() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/StringLength.php b/ide/2.0.4/Phalcon/mvc/model/validator/StringLength.php
new file mode 100644
index 000000000..c69a446f4
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/StringLength.php
@@ -0,0 +1,46 @@
+
+ * use Phalcon\Mvc\Model\Validator\StringLength as StringLengthValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new StringLengthValidator(array(
+ * "field" => 'name_last',
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class StringLength extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_StringLength() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/Uniqueness.php b/ide/2.0.4/Phalcon/mvc/model/validator/Uniqueness.php
new file mode 100644
index 000000000..ce19e6c1d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/Uniqueness.php
@@ -0,0 +1,49 @@
+
+<<<<<<< HEAD
+ * use Phalcon\Mvc\Model;
+ * use Phalcon\Mvc\Model\Validator\Uniqueness;
+ * class Subscriptors extends Model
+=======
+ * use Phalcon\Mvc\Model\Validator\Uniqueness as Uniqueness;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new Uniqueness(array(
+ * "field" => 'email'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Uniqueness extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Uniqueness() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/model/validator/Url.php b/ide/2.0.4/Phalcon/mvc/model/validator/Url.php
new file mode 100644
index 000000000..2a4084800
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/model/validator/Url.php
@@ -0,0 +1,42 @@
+
+ * use Phalcon\Mvc\Model\Validator\Url as UrlValidator;
+ * class Posts extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new UrlValidator(array(
+ * 'field' => 'source_url'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Url extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+<<<<<<< HEAD
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Url() {}
+=======
+ public function validate(\Phalcon\Mvc\ModelInterface $record) {}
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/router/Annotations.php b/ide/2.0.4/Phalcon/mvc/router/Annotations.php
new file mode 100644
index 000000000..20343fb9d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/router/Annotations.php
@@ -0,0 +1,105 @@
+
+ * $di['router'] = function() {
+ * //Use the annotations router
+ * $router = new Annotations(false);
+ * //This will do the same as above but only if the handled uri starts with /robots
+ * $router->addResource('Robots', '/robots');
+ * return $router;
+ * };
+ *
+ */
+class Annotations extends \Phalcon\Mvc\Router
+{
+
+ protected $_handlers;
+
+
+ protected $_processed = false;
+
+
+ protected $_controllerSuffix = "Controller";
+
+
+ protected $_actionSuffix = "Action";
+
+
+ protected $_routePrefix;
+
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ *
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addResource($handler, $prefix = null) {}
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ * The class is located in a module
+ *
+ * @param string $module
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addModuleResource($module, $handler, $prefix = null) {}
+
+ /**
+ * Produce the routing parameters from the rewrite information
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Checks for annotations in the controller docblock
+ *
+ * @param string $handler
+ * @param mixed $annotation
+ */
+ public function processControllerAnnotation($handler, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Checks for annotations in the public methods of the controller
+ *
+ * @param string $module
+ * @param string $namespaceName
+ * @param string $controller
+ * @param string $action
+ * @param \Phalcon\Annotations\Annotation $annotation
+ */
+ public function processActionAnnotation($module, $namespaceName, $controller, $action, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Changes the controller class suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Changes the action method suffix
+ *
+ * @param string $actionSuffix
+ */
+ public function setActionSuffix($actionSuffix) {}
+
+ /**
+ * Return the registered resources
+ *
+ * @return array
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/router/Exception.php b/ide/2.0.4/Phalcon/mvc/router/Exception.php
new file mode 100644
index 000000000..e8a40f672
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/router/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+class Group implements \Phalcon\Mvc\Router\GroupInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_hostname;
+
+
+ protected $_paths;
+
+
+ protected $_routes;
+
+
+ protected $_beforeMatch;
+
+
+ /**
+ * Phalcon\Mvc\Router\Group constructor
+ *
+ * @param mixed $paths
+ */
+ public function __construct($paths = null) {}
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param mixed $paths
+ * @return GroupInterface
+ */
+ public function setPaths($paths) {}
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addGet($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPost($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPut($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPatch($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addDelete($pattern, $paths = null) {}
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addOptions($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addHead($pattern, $paths = null) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Adds a route applying the common attributes
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ protected function _addRoute($pattern, $paths = null, $httpMethods = null) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/router/GroupInterface.php b/ide/2.0.4/Phalcon/mvc/router/GroupInterface.php
new file mode 100644
index 000000000..bd9481889
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/router/GroupInterface.php
@@ -0,0 +1,186 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+interface GroupInterface
+{
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname);
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname();
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix);
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix();
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch);
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch();
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param array $paths
+ * @return \Phalcon\Mvc\Router\Group
+ */
+ public function setPaths($paths);
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths();
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes();
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null);
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null);
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear();
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/router/Route.php b/ide/2.0.4/Phalcon/mvc/router/Route.php
new file mode 100644
index 000000000..5cb392f08
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/router/Route.php
@@ -0,0 +1,243 @@
+
+ * $route->via('GET');
+ * $route->via(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function via($httpMethods) {}
+
+ /**
+ * Extracts parameters from a string
+ *
+ * @param string $pattern
+ * @return array|bool
+ */
+ public function extractNamedParams($pattern) {}
+
+ /**
+ * Reconfigure the route adding a new pattern and a set of paths
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ */
+ public function reConfigure($pattern, $paths = null) {}
+
+ /**
+ * Returns routePaths
+ *
+ * @param mixed $paths
+ * @return array
+ */
+ public static function getRoutePaths($paths = null) {}
+
+ /**
+ * Returns the route's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets the route's name
+ *
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $callback
+ * @return Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Sets a set of HTTP methods that constraint the matching of the route (alias of via)
+ *
+ * $route->setHttpMethods('GET');
+ * $route->setHttpMethods(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function setHttpMethods($httpMethods) {}
+
+ /**
+ * Returns the HTTP methods that constraint matching the route
+ *
+ * @return array|string
+ */
+ public function getHttpMethods() {}
+
+ /**
+ * Sets a hostname restriction to the route
+ *
+ * $route->setHostname('localhost');
+ *
+ *
+ * @param string $hostname
+ * @return Route
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction if any
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Sets the group associated with the route
+ *
+ * @param mixed $group
+ * @return Route
+ */
+ public function setGroup(GroupInterface $group) {}
+
+ /**
+ * Returns the group associated with the route
+ *
+ * @return null|GroupInterface
+ */
+ public function getGroup() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param mixed $converter
+ * @return Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/router/RouteInterface.php b/ide/2.0.4/Phalcon/mvc/router/RouteInterface.php
new file mode 100644
index 000000000..e49f3af1d
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/router/RouteInterface.php
@@ -0,0 +1,113 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Returns cached output on another view stage
+ *
+ * @return array
+ */
+ public function getContent();
+
+ /**
+ * Renders a partial inside another view
+ *
+ * @param string $partialPath
+<<<<<<< HEAD
+ * @param mixed $params
+ * @return string
+ */
+ public function partial($partialPath, $params = null);
+=======
+ * @return string
+ */
+ public function partial($partialPath);
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+ /**
+ * Renders a view using the template engine
+ *
+ * @param string $path
+ * @param mixed $params
+ * @param bool $mustClean
+ */
+ public function render($path, $params, $mustClean = false);
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/view/Exception.php b/ide/2.0.4/Phalcon/mvc/view/Exception.php
new file mode 100644
index 000000000..d6208f6cb
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/view/Exception.php
@@ -0,0 +1,12 @@
+
+ * $view = new \Phalcon\Mvc\View\Simple();
+ * echo $view->render('templates/my-view', array('content' => $html));
+ * //or with filename with extension
+ * echo $view->render('templates/my-view.volt', array('content' => $html));
+ *
+ */
+class Simple extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewBaseInterface
+{
+
+ protected $_options;
+
+
+ protected $_viewsDir;
+
+
+ protected $_partialsDir;
+
+
+ protected $_viewParams;
+
+
+ protected $_engines = false;
+
+
+ protected $_registeredEngines;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_content;
+
+
+ protected $_cache = false;
+
+
+ protected $_cacheOptions;
+
+
+
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View\Simple constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Tries to render the view with every engine registered in the component
+ *
+ * @param string $path
+ * @param array $params
+ */
+ protected final function _internalRender($path, $params) {}
+
+ /**
+ * Renders a view
+ *
+ * @param string $path
+ * @param array $params
+ * @return string
+ */
+ public function render($path, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Sets the cache options
+ *
+ * @param array $options
+ * @return \Phalcon\Mvc\View\Simple
+ */
+ public function setCacheOptions($options) {}
+
+ /**
+ * Returns the cache options
+ *
+ * @return array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param mixed $options
+ * @return Simple
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param bool $merge
+ * @return Simple
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return Simple
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/mvc/view/engine/Php.php b/ide/2.0.4/Phalcon/mvc/view/engine/Php.php
new file mode 100644
index 000000000..d554be8de
--- /dev/null
+++ b/ide/2.0.4/Phalcon/mvc/view/engine/Php.php
@@ -0,0 +1,21 @@
+
+ * $compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();
+ * $compiler->compile('views/partials/header.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ */
+class Compiler implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_view;
+
+
+ protected $_options;
+
+
+ protected $_arrayHelpers;
+
+
+ protected $_level = 0;
+
+
+ protected $_foreachLevel = 0;
+
+
+ protected $_blockLevel = 0;
+
+
+ protected $_exprLevel = 0;
+
+
+ protected $_extended = false;
+
+
+ protected $_autoescape = false;
+
+
+ protected $_extendedBlocks;
+
+
+ protected $_currentBlock;
+
+
+ protected $_blocks;
+
+
+ protected $_forElsePointers;
+
+
+ protected $_loopPointers;
+
+
+ protected $_extensions;
+
+
+ protected $_functions;
+
+
+ protected $_filters;
+
+
+ protected $_macros;
+
+
+ protected $_prefix;
+
+
+ protected $_currentPath;
+
+
+ protected $_compiledTemplatePath;
+
+
+ /**
+ * Phalcon\Mvc\View\Engine\Volt\Compiler
+ *
+ * @param mixed $view
+ */
+ public function __construct(\Phalcon\Mvc\ViewBaseInterface $view = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the compiler options
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Sets a single compiler option
+ *
+ * @param string $option
+ * @param mixed $value
+ */
+ public function setOption($option, $value) {}
+
+ /**
+ * Returns a compiler's option
+ *
+ * @param string $option
+ * @return string
+ */
+ public function getOption($option) {}
+
+ /**
+ * Returns the compiler options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+ * Fires an event to registered extensions
+ *
+ * @param string $name
+ * @param array $arguments
+ * @return mixed
+ */
+ public final function fireExtensionEvent($name, $arguments = null) {}
+
+ /**
+ * Registers a Volt's extension
+ *
+ * @param mixed $extension
+ * @return Compiler
+ */
+ public function addExtension($extension) {}
+
+ /**
+ * Returns the list of extensions registered in Volt
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register a new function in the compiler
+ *
+ * @param string $name
+<<<<<<< HEAD
+ * @param mixed $definition
+ * @return Compiler
+=======
+ * @param Closure|string $definition
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addFunction($name, $definition) {}
+
+ /**
+ * Register the user registered functions
+ *
+ * @return array
+ */
+ public function getFunctions() {}
+
+ /**
+ * Register a new filter in the compiler
+ *
+ * @param string $name
+<<<<<<< HEAD
+ * @param mixed $definition
+ * @return Compiler
+=======
+ * @param Closure|string $definition
+ * @return \Phalcon\Mvc\View\Engine\Volt\Compiler
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function addFilter($name, $definition) {}
+
+ /**
+ * Register the user registered filters
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+ /**
+ * Set a unique prefix to be used as prefix for compiled variables
+ *
+ * @param string $prefix
+ * @return Compiler
+ */
+ public function setUniquePrefix($prefix) {}
+
+ /**
+ * Return a unique prefix to be used as prefix for compiled variables and contexts
+ *
+ * @return string
+ */
+ public function getUniquePrefix() {}
+
+ /**
+ * Resolves attribute reading
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function attributeReader($expr) {}
+
+ /**
+ * Resolves function intermediate code into PHP function calls
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function functionCall($expr) {}
+
+ /**
+ * Resolves filter intermediate code into a valid PHP expression
+ *
+ * @param array $test
+ * @param string $left
+ * @return string
+ */
+ public function resolveTest($test, $left) {}
+
+ /**
+ * Resolves filter intermediate code into PHP function calls
+ *
+ * @param array $filter
+ * @param string $left
+ * @return string
+ */
+ final protected function resolveFilter($filter, $left) {}
+
+ /**
+ * Resolves an expression node in an AST volt tree
+ *
+ * @param array $expr
+ * @return string
+ */
+ final public function expression($expr) {}
+
+ /**
+ * Compiles a block of statements
+ *
+ * @param array $statements
+ * @return string|array
+ */
+ final protected function _statementListOrExtends($statements) {}
+
+ /**
+ * Compiles a "foreach" intermediate code representation into plain PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileForeach($statement, $extendsMode = false) {}
+
+ /**
+ * Generates a 'forelse' PHP code
+ *
+ * @return string
+ */
+ public function compileForElse() {}
+
+ /**
+ * Compiles a 'if' statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileIf($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "elseif" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileElseIf($statement) {}
+
+ /**
+ * Compiles a "cache" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileCache($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "set" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileSet($statement) {}
+
+ /**
+ * Compiles a "do" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileDo($statement) {}
+
+ /**
+ * Compiles a "return" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileReturn($statement) {}
+
+ /**
+ * Compiles a "autoescape" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileAutoEscape($statement, $extendsMode) {}
+
+ /**
+ * Compiles a '{{' '}}' statement returning PHP code
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileEcho($statement) {}
+
+ /**
+ * Compiles a 'include' statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileInclude($statement) {}
+
+ /**
+ * Compiles macros
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileMacro($statement, $extendsMode) {}
+
+ /**
+ * Compiles calls to macros
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileCall($statement, $extendsMode) {}
+
+ /**
+ * Traverses a statement list compiling each of its nodes
+ *
+ * @param array $statements
+ * @param bool $extendsMode
+ * @return string
+ */
+ final protected function _statementList($statements, $extendsMode = false) {}
+
+ /**
+ * Compiles a Volt source code returning a PHP plain version
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ protected function _compileSource($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a string
+ *
+ * echo $compiler->compileString('{{ "hello world" }}');
+ *
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileString($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file forcing the destination path
+ *
+ * $compiler->compile('views/layouts/main.volt', 'views/layouts/main.volt.php');
+ *
+ *
+ * @param string $path
+ * @param string $compiledPath
+ * @param boolean $extendsMode
+ * @return string|array
+ */
+ public function compileFile($path, $compiledPath, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file applying the compiler options
+ * This method does not return the compiled path if the template was not compiled
+ *
+ * $compiler->compile('views/layouts/main.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ *
+ * @param string $templatePath
+<<<<<<< HEAD
+ * @param bool $extendsMode
+=======
+ * @param boolean $extendsMode
+ * @return string|array
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ */
+ public function compile($templatePath, $extendsMode = false) {}
+
+ /**
+ * Returns the path that is currently being compiled
+ *
+ * @return string
+ */
+ public function getTemplatePath() {}
+
+ /**
+ * Returns the path to the last compiled template
+ *
+ * @return string
+ */
+ public function getCompiledTemplatePath() {}
+
+ /**
+ * Parses a Volt template returning its intermediate representation
+ *
+ * print_r($compiler->parse('{{ 3 + 2 }}'));
+ *
+ *
+ * @param string $viewCode
+ * @return array
+ */
+ public function parse($viewCode) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/paginator/Adapter.php b/ide/2.0.4/Phalcon/paginator/Adapter.php
new file mode 100644
index 000000000..8a4dcf3fe
--- /dev/null
+++ b/ide/2.0.4/Phalcon/paginator/Adapter.php
@@ -0,0 +1,44 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => Robots::find(),
+ * "limit" => 25,
+ * "page" => $currentPage
+ * )
+ * );
+ * $paginate = $paginator->getPaginate();
+ *
+ */
+class Model extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\Model constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdclass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/paginator/adapter/NativeArray.php b/ide/2.0.4/Phalcon/paginator/adapter/NativeArray.php
new file mode 100644
index 000000000..d9dc50611
--- /dev/null
+++ b/ide/2.0.4/Phalcon/paginator/adapter/NativeArray.php
@@ -0,0 +1,46 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => array(
+ * array('id' => 1, 'name' => 'Artichoke'),
+ * array('id' => 2, 'name' => 'Carrots'),
+ * array('id' => 3, 'name' => 'Beet'),
+ * array('id' => 4, 'name' => 'Lettuce'),
+ * array('id' => 5, 'name' => '')
+ * ),
+ * "limit" => 2,
+ * "page" => $currentPage
+ * )
+ * );
+ *
+ */
+class NativeArray extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of the paginator
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\NativeArray constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/paginator/adapter/QueryBuilder.php b/ide/2.0.4/Phalcon/paginator/adapter/QueryBuilder.php
new file mode 100644
index 000000000..3a6af396f
--- /dev/null
+++ b/ide/2.0.4/Phalcon/paginator/adapter/QueryBuilder.php
@@ -0,0 +1,69 @@
+
+ * $builder = $this->modelsManager->createBuilder()
+ * ->columns('id, name')
+ * ->from('Robots')
+ * ->orderBy('name');
+ * $paginator = new Phalcon\Paginator\Adapter\QueryBuilder(array(
+ * "builder" => $builder,
+ * "limit"=> 20,
+ * "page" => 1
+ * ));
+ *
+ */
+class QueryBuilder extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config;
+
+ /**
+ * Paginator's data
+ */
+ protected $_builder;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\QueryBuilder
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Get the current page number
+ *
+ * @return int
+ */
+ public function getCurrentPage() {}
+
+ /**
+ * Set query builder object
+ *
+ * @param mixed $builder
+ * @return QueryBuilder
+ */
+ public function setQueryBuilder(\Phalcon\Mvc\Model\Query\Builder $builder) {}
+
+ /**
+ * Get query builder object
+ *
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function getQueryBuilder() {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/queue/Beanstalk.php b/ide/2.0.4/Phalcon/queue/Beanstalk.php
new file mode 100644
index 000000000..f5377b197
--- /dev/null
+++ b/ide/2.0.4/Phalcon/queue/Beanstalk.php
@@ -0,0 +1,135 @@
+
+<<<<<<< HEAD
+ * $session->setOptions(array(
+=======
+ * session->setOptions(array(
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ *
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get internal options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+<<<<<<< HEAD
+ * Set session name
+ *
+ * @param string $name
+ */
+ public function setName($name) {}
+
+ /**
+ * Get session name
+ */
+ public function getName() {}
+
+ /**
+=======
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ * Gets a session variable from an application context
+ *
+ * @param string $index
+ * @param mixed $defaultValue
+ * @param boolean $remove
+ * @return mixed
+ */
+ public function get($index, $defaultValue = null, $remove = false) {}
+
+ /**
+ * Sets a session variable in an application context
+ *
+<<<<<<< HEAD
+ * $session->set('auth', 'yes');
+=======
+ * session->set('auth', 'yes');
+>>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+ *
+ *
+ * @param string $index
+ * @param string $value
+ */
+ public function set($index, $value) {}
+
+ /**
+ * Check whether a session variable is set in an application context
+ *
+ * var_dump($session->has('auth'));
+ *
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function has($index) {}
+
+ /**
+ * Removes a session variable from an application context
+ *
+ * $session->remove('auth');
+ *
+ *
+ * @param string $index
+ */
+ public function remove($index) {}
+
+ /**
+ * Returns active session id
+ *
+ * echo $session->getId();
+ *
+ *
+ * @return string
+ */
+ public function getId() {}
+
+ /**
+ * Set the current session id
+ *
+ * $session->setId($id);
+ *
+ *
+ * @param string $id
+ */
+ public function setId($id) {}
+
+ /**
+ * Check whether the session has been started
+ *
+ * var_dump($session->isStarted());
+ *
+ *
+ * @return bool
+ */
+ public function isStarted() {}
+
+ /**
+ * Destroys the active session
+ *
+ * var_dump($session->destroy());
+ *
+ *
+ * @return bool
+ */
+ public function destroy() {}
+
+ /**
+ * Returns the status of the current session. For PHP 5.3 this function will always return SESSION_NONE
+ *
+ * var_dump($session->status());
+ * // PHP 5.4 and above will give meaningful messages, 5.3 gets SESSION_NONE always
+ * if ($session->status() !== $session::SESSION_ACTIVE) {
+ * $session->start();
+ * }
+ *
+ *
+ * @return int
+ */
+ public function status() {}
+
+ /**
+ * Alias: Gets a session variable from an application context
+ *
+ * @param string $index
+ * @return mixed
+ */
+ public function __get($index) {}
+
+ /**
+ * Alias: Sets a session variable in an application context
+ *
+ * @param string $index
+ * @param string $value
+ */
+ public function __set($index, $value) {}
+
+ /**
+ * Alias: Check whether a session variable is set in an application context
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function __isset($index) {}
+
+ /**
+ * Alias: Removes a session variable from an application context
+ *
+ * @param string $index
+ */
+ public function __unset($index) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/session/AdapterInterface.php b/ide/2.0.4/Phalcon/session/AdapterInterface.php
new file mode 100644
index 000000000..814efc411
--- /dev/null
+++ b/ide/2.0.4/Phalcon/session/AdapterInterface.php
@@ -0,0 +1,84 @@
+
+ * $user = new \Phalcon\Session\Bag('user');
+ * $user->name = "Kimbra Johnson";
+ * $user->age = 22;
+ *
+ */
+class Bag implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Session\BagInterface, \IteratorAggregate, \ArrayAccess, \Countable
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_name = null;
+
+
+ protected $_data;
+
+
+ protected $_initialized = false;
+
+
+ protected $_session;
+
+
+ /**
+ * Phalcon\Session\Bag constructor
+ *
+ * @param string $name
+ */
+ public function __construct($name) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed
+ */
+ public function initialize() {}
+
+ /**
+ * Destroyes the session bag
+ *
+ * $user->destroy();
+ *
+ */
+ public function destroy() {}
+
+ /**
+ * Sets a value in the session bag
+ *
+ * $user->set('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function set($property, $value) {}
+
+ /**
+ * Magic setter to assign values to the session bag
+ *
+ * $user->name = "Kimbra";
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Obtains a value from the session bag optionally setting a default value
+ *
+ * echo $user->get('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $defaultValue
+ * @return mixed
+ */
+ public function get($property, $defaultValue = null) {}
+
+ /**
+ * Magic getter to obtain values from the session bag
+ *
+ * echo $user->name;
+ *
+ *
+ * @param string $property
+ * @return mixed
+ */
+ public function __get($property) {}
+
+ /**
+ * Check whether a property is defined in the internal bag
+ *
+ * var_dump($user->has('name'));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function has($property) {}
+
+ /**
+ * Magic isset to check whether a property is defined in the bag
+ *
+ * var_dump(isset($user['name']));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Removes a property from the internal bag
+ *
+ * $user->remove('name');
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function remove($property) {}
+
+ /**
+ * Magic unset to remove items using the array syntax
+ *
+ * unset($user['name']);
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __unset($property) {}
+
+ /**
+ * Return length of bag
+ *
+ * echo $user->count();
+ *
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Returns the bag iterator
+ *
+ * @return \ArrayIterator
+ */
+ public final function getIterator() {}
+
+ /**
+ * @param string $property
+ * @param mixed $value
+ */
+ public final function offsetSet($property, $value) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetExists($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetUnset($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetGet($property) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/session/BagInterface.php b/ide/2.0.4/Phalcon/session/BagInterface.php
new file mode 100644
index 000000000..c36cc1973
--- /dev/null
+++ b/ide/2.0.4/Phalcon/session/BagInterface.php
@@ -0,0 +1,71 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Files extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+}
diff --git a/ide/2.0.4/Phalcon/session/adapter/Libmemcached.php b/ide/2.0.4/Phalcon/session/adapter/Libmemcached.php
new file mode 100644
index 000000000..54ec0e0ad
--- /dev/null
+++ b/ide/2.0.4/Phalcon/session/adapter/Libmemcached.php
@@ -0,0 +1,88 @@
+
+ * $session = new Phalcon\Session\Adapter\Libmemcached(array(
+ * 'servers' => array(
+ * array('host' => 'localhost', 'port' => 11211, 'weight' => 1),
+ * ),
+ * 'client' => array(
+ * Memcached::OPT_HASH => Memcached::HASH_MD5,
+ * Memcached::OPT_PREFIX_KEY => 'prefix.',
+ * ),
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Libmemcached extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_libmemcached = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getLibmemcached() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Libmemcached constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options) {}
+
+ /**
+ * @return bool
+ */
+ public function open() {}
+
+ /**
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @return bool
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/session/adapter/Memcache.php b/ide/2.0.4/Phalcon/session/adapter/Memcache.php
new file mode 100644
index 000000000..83b9edf17
--- /dev/null
+++ b/ide/2.0.4/Phalcon/session/adapter/Memcache.php
@@ -0,0 +1,79 @@
+
+ * $session = new \Phalcon\Session\Adapter\Memcache(array(
+ * 'uniqueId' => 'my-private-app'
+ * 'host' => '127.0.0.1',
+ * 'port' => 11211,
+ * 'persistent' => TRUE,
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Memcache extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_memcache = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getMemcache() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Memcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = array()) {}
+
+
+ public function open() {}
+
+
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.4/Phalcon/tag/Exception.php b/ide/2.0.4/Phalcon/tag/Exception.php
new file mode 100644
index 000000000..8d2604755
--- /dev/null
+++ b/ide/2.0.4/Phalcon/tag/Exception.php
@@ -0,0 +1,12 @@
+>>>>>> 5cd73180ea748c3d5e180a24610161d9730cd146
+
+}
diff --git a/ide/2.0.4/Phalcon/translate/adapter/Gettext.php b/ide/2.0.4/Phalcon/translate/adapter/Gettext.php
new file mode 100644
index 000000000..5f1a0cf24
--- /dev/null
+++ b/ide/2.0.4/Phalcon/translate/adapter/Gettext.php
@@ -0,0 +1,154 @@
+
+ * print_r($messages[0]);
+ *
+ *
+ * @param int $index
+ * @return \Phalcon\Validation\Message
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $messages[0] = new \Phalcon\Validation\Message('This is a message');
+ *
+ *
+ * @param int $index
+ * @param \Phalcon\Validation\Message $message
+ */
+ public function offsetSet($index, $message) {}
+
+ /**
+ * Checks if an index exists
+ *
+ * var_dump(isset($message['database']));
+ *
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Removes a message from the list
+ *
+ * unset($message['database']);
+ *
+ *
+ * @param string $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Appends a message to the group
+ *
+ * $messages->appendMessage(new \Phalcon\Validation\Message('This is a message'));
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Validation\MessageInterface $message) {}
+
+ /**
+ * Appends an array of messages to the group
+ *
+ * $messages->appendMessages($messagesArray);
+ *
+ *
+ * @param \Phalcon\Validation\MessageInterface[] $messages
+ */
+ public function appendMessages($messages) {}
+
+ /**
+ * Filters the message group by field name
+ *
+ * @param string $fieldName
+ * @return array
+ */
+ public function filter($fieldName) {}
+
+ /**
+ * Returns the number of messages in the list
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current message in the iterator
+ *
+ * @return \Phalcon\Validation\Message
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current message in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable when exporting
+ *
+ * @param array $group
+ * @return \Phalcon\Validation\Message\Group
+ */
+ public static function __set_state($group) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Alnum.php b/ide/2.0.4/Phalcon/validation/validator/Alnum.php
new file mode 100644
index 000000000..96250226c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Alnum.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alnum as AlnumValidator;
+ * $validator->add('username', new AlnumValidator(array(
+ * 'message' => ':field must contain only alphanumeric characters'
+ * )));
+ *
+ */
+class Alnum extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Alpha.php b/ide/2.0.4/Phalcon/validation/validator/Alpha.php
new file mode 100644
index 000000000..3860505fd
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Alpha.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alpha as AlphaValidator;
+ * $validator->add('username', new AlphaValidator(array(
+ * 'message' => ':field must contain only letters'
+ * )));
+ *
+ */
+class Alpha extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Between.php b/ide/2.0.4/Phalcon/validation/validator/Between.php
new file mode 100644
index 000000000..9a765abd7
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Between.php
@@ -0,0 +1,30 @@
+
+ * use Phalcon\Validation\Validator\Between;
+ * validator->add('name', new Between(array(
+ * 'minimum' => 0,
+ * 'maximum' => 100,
+ * 'message' => 'The price must be between 0 and 100'
+ * )));
+ *
+ */
+class Between extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Confirmation.php b/ide/2.0.4/Phalcon/validation/validator/Confirmation.php
new file mode 100644
index 000000000..75e1ac710
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Confirmation.php
@@ -0,0 +1,37 @@
+
+ * use Phalcon\Validation\Validator\Confirmation;
+ * $validator->add('password', new Confirmation(array(
+ * 'message' => 'Password doesn\'t match confirmation',
+ * 'with' => 'confirmPassword'
+ * )));
+ *
+ */
+class Confirmation extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+ /**
+ * Compare strings
+ *
+ * @param string $a
+ * @param string $b
+ * @return bool
+ */
+ protected final function compare($a, $b) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Digit.php b/ide/2.0.4/Phalcon/validation/validator/Digit.php
new file mode 100644
index 000000000..dae4e4dbe
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Digit.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Digit as DigitValidator;
+ * $validator->add('height', new DigitValidator(array(
+ * 'message' => ':field must be numeric'
+ * )));
+ *
+ */
+class Digit extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Email.php b/ide/2.0.4/Phalcon/validation/validator/Email.php
new file mode 100644
index 000000000..8951305fc
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Email.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Email as EmailValidator;
+ * $validator->add('email', new EmailValidator(array(
+ * 'message' => 'The e-mail is not valid'
+ * )));
+ *
+ */
+class Email extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/ExclusionIn.php b/ide/2.0.4/Phalcon/validation/validator/ExclusionIn.php
new file mode 100644
index 000000000..d6bd01efa
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/ExclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\ExclusionIn;
+ * $validator->add('status', new ExclusionIn(array(
+ * 'message' => 'The status must not be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class ExclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/File.php b/ide/2.0.4/Phalcon/validation/validator/File.php
new file mode 100644
index 000000000..96121dc85
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/File.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\File as FileValidator;
+ * $validator->add('file', new FileValidator(array(
+ * 'maxSize' => '2M',
+ * 'messageSize' => ':field exceeds the max filesize (:max)',
+ * 'allowedTypes' => array('image/jpeg', 'image/png'),
+ * 'messageType' => 'Allowed file types are :types',
+ * 'maxResolution' => '800x600',
+ * 'messageMaxResolution' => 'Max resolution of :field is :max'
+ * )));
+ *
+ */
+class File extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Identical.php b/ide/2.0.4/Phalcon/validation/validator/Identical.php
new file mode 100644
index 000000000..d5ee453cc
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Identical.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Identical;
+ * $validator->add('terms', new Identical(array(
+ * 'accepted' => 'yes',
+ * 'message' => 'Terms and conditions must be accepted'
+ * )));
+ *
+ */
+class Identical extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/InclusionIn.php b/ide/2.0.4/Phalcon/validation/validator/InclusionIn.php
new file mode 100644
index 000000000..4bee62023
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/InclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\InclusionIn;
+ * $validator->add('status', new InclusionIn(array(
+ * 'message' => 'The status must be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class InclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Numericality.php b/ide/2.0.4/Phalcon/validation/validator/Numericality.php
new file mode 100644
index 000000000..5b68ec926
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Numericality.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Numericality;
+ * $validator->add('price', new Numericality(array(
+ * 'message' => ':field is not numeric'
+ * )));
+ *
+ */
+class Numericality extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/PresenceOf.php b/ide/2.0.4/Phalcon/validation/validator/PresenceOf.php
new file mode 100644
index 000000000..30ba729ed
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/PresenceOf.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\PresenceOf;
+ * $validator->add('name', new PresenceOf(array(
+ * 'message' => 'The name is required'
+ * )));
+ *
+ */
+class PresenceOf extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Regex.php b/ide/2.0.4/Phalcon/validation/validator/Regex.php
new file mode 100644
index 000000000..8b73552b6
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Regex.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Regex as RegexValidator;
+ * $validator->add('created_at', new RegexValidator(array(
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/',
+ * 'message' => 'The creation date is invalid'
+ * )));
+ *
+ */
+class Regex extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/StringLength.php b/ide/2.0.4/Phalcon/validation/validator/StringLength.php
new file mode 100644
index 000000000..2bafa9675
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/StringLength.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\StringLength as StringLength;
+ * $validation->add('name_last', new StringLength(array(
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ *
+ */
+class StringLength extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Uniqueness.php b/ide/2.0.4/Phalcon/validation/validator/Uniqueness.php
new file mode 100644
index 000000000..79ef4083c
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Uniqueness.php
@@ -0,0 +1,35 @@
+
+ * use Phalcon\Validation\Validator\Uniqueness as UniquenessValidator;
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'message' => ':field must be unique'
+ * )));
+ *
+ * Different attribute from the field
+ *
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'attribute' => 'nick'
+ * )));
+ *
+ */
+class Uniqueness extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.4/Phalcon/validation/validator/Url.php b/ide/2.0.4/Phalcon/validation/validator/Url.php
new file mode 100644
index 000000000..76ab65b91
--- /dev/null
+++ b/ide/2.0.4/Phalcon/validation/validator/Url.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Url as UrlValidator;
+ * $validator->add('url', new UrlValidator(array(
+ * 'message' => ':field must be a url'
+ * )));
+ *
+ */
+class Url extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Acl.php b/ide/2.0.5/Phalcon/Acl.php
new file mode 100644
index 000000000..54a8d3549
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Acl.php
@@ -0,0 +1,45 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * //Default action is deny access
+ * $acl->setDefaultAction(\Phalcon\Acl::DENY);
+ * //Create some roles
+ * $roleAdmins = new \Phalcon\Acl\Role('Administrators', 'Super-User role');
+ * $roleGuests = new \Phalcon\Acl\Role('Guests');
+ * //Add "Guests" role to acl
+ * $acl->addRole($roleGuests);
+ * //Add "Designers" role to acl
+ * $acl->addRole('Designers');
+ * //Define the "Customers" resource
+ * $customersResource = new \Phalcon\Acl\Resource('Customers', 'Customers management');
+ * //Add "customers" resource with a couple of operations
+ * $acl->addResource($customersResource, 'search');
+ * $acl->addResource($customersResource, array('create', 'update'));
+ * //Set access level for roles into resources
+ * $acl->allow('Guests', 'Customers', 'search');
+ * $acl->allow('Guests', 'Customers', 'create');
+ * $acl->deny('Guests', 'Customers', 'update');
+ * //Check whether role has access to the operations
+ * $acl->isAllowed('Guests', 'Customers', 'edit'); //Returns 0
+ * $acl->isAllowed('Guests', 'Customers', 'search'); //Returns 1
+ * $acl->isAllowed('Guests', 'Customers', 'create'); //Returns 1
+ *
+ */
+abstract class Acl
+{
+
+ const ALLOW = 1;
+
+
+ const DENY = 0;
+
+
+}
diff --git a/ide/2.0.5/Phalcon/Config.php b/ide/2.0.5/Phalcon/Config.php
new file mode 100644
index 000000000..b3112b0da
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Config.php
@@ -0,0 +1,145 @@
+
+ * $config = new \Phalcon\Config(array(
+ * "database" => array(
+ * "adapter" => "Mysql",
+ * "host" => "localhost",
+ * "username" => "scott",
+ * "password" => "cheetah",
+ * "dbname" => "test_db"
+ * ),
+ * "phalcon" => array(
+ * "controllersDir" => "../app/controllers/",
+ * "modelsDir" => "../app/models/",
+ * "viewsDir" => "../app/views/"
+ * )
+ * ));
+ *
+ */
+class Config implements \ArrayAccess, \Countable
+{
+
+ /**
+ * Phalcon\Config constructor
+ *
+ * @param array $arrayConfig
+ */
+ public function __construct($arrayConfig = null) {}
+
+ /**
+ * Allows to check whether an attribute is defined using the array-syntax
+ *
+ * var_dump(isset($config['database']));
+ *
+ *
+ * @param mixed $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets an attribute from the configuration, if the attribute isn't defined returns null
+ * If the value is exactly null or is not defined the default value will be used instead
+ *
+ * echo $config->get('controllersDir', '../app/controllers/');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $defaultValue
+ */
+ public function get($index, $defaultValue = null) {}
+
+ /**
+ * Gets an attribute using the array-syntax
+ *
+ * print_r($config['database']);
+ *
+ *
+ * @param mixed $index
+ * @return string
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $config['database'] = array('type' => 'Sqlite');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Unsets an attribute using the array-syntax
+ *
+ * unset($config['database']);
+ *
+ *
+ * @param mixed $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Merges a configuration into the current one
+ *
+ * $appConfig = new \Phalcon\Config(array('database' => array('host' => 'localhost')));
+ * $globalConfig->merge($config2);
+ *
+ *
+ * @param mixed $config
+ * @return Config
+ */
+ public function merge(Config $config) {}
+
+ /**
+ * Converts recursively the object to an array
+ *
+ * print_r($config->toArray());
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Returns the count of properties set in the config
+ *
+ * print count($config);
+ *
+ * or
+ *
+ * print $config->count();
+ *
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Restores the state of a Phalcon\Config object
+ *
+ * @param array $data
+ * @return Config
+ */
+ public static function __set_state($data) {}
+
+ /**
+ * Helper method for merge configs (forwarding nested config instance)
+ *
+ * @param Config $config
+ * @param Config $instance = null
+ * @return Config config
+ */
+ protected final function _merge(Config $config, $instance = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Crypt.php b/ide/2.0.5/Phalcon/Crypt.php
new file mode 100644
index 000000000..7ff497474
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Crypt.php
@@ -0,0 +1,194 @@
+
+ * $crypt = new \Phalcon\Crypt();
+ * $key = 'le password';
+ * $text = 'This is a secret text';
+ * $encrypted = $crypt->encrypt($text, $key);
+ * echo $crypt->decrypt($encrypted, $key);
+ *
+ */
+class Crypt implements \Phalcon\CryptInterface
+{
+
+ const PADDING_DEFAULT = 0;
+
+
+ const PADDING_ANSI_X_923 = 1;
+
+
+ const PADDING_PKCS7 = 2;
+
+
+ const PADDING_ISO_10126 = 3;
+
+
+ const PADDING_ISO_IEC_7816_4 = 4;
+
+
+ const PADDING_ZERO = 5;
+
+
+ const PADDING_SPACE = 6;
+
+
+ protected $_key;
+
+
+ protected $_padding = 0;
+
+
+ protected $_mode = "cbc";
+
+
+ protected $_cipher = "rijndael-256";
+
+
+ /**
+ * @brief Phalcon\CryptInterface Phalcon\Crypt::setPadding(int $scheme)
+ * @param int $scheme Padding scheme
+ * @return \Phalcon\CryptInterface
+ */
+ public function setPadding($scheme) {}
+
+ /**
+ * Sets the cipher algorithm
+ *
+ * @param string $cipher
+ * @return Crypt
+ */
+ public function setCipher($cipher) {}
+
+ /**
+ * Returns the current cipher
+ *
+ * @return string
+ */
+ public function getCipher() {}
+
+ /**
+ * Sets the encrypt/decrypt mode
+ *
+ * @param string $mode
+ * @return Crypt
+ */
+ public function setMode($mode) {}
+
+ /**
+ * Returns the current encryption mode
+ *
+ * @return string
+ */
+ public function getMode() {}
+
+ /**
+ * Sets the encryption key
+ *
+ * @param string $key
+ * @return Crypt
+ */
+ public function setKey($key) {}
+
+ /**
+ * Returns the encryption key
+ *
+ * @return string
+ */
+ public function getKey() {}
+
+ /**
+ * Adds padding @a padding_type to @a text
+ *
+ * @see http://www.di-mgt.com.au/cryptopad.html
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ * @param return_value $Result, possibly padded
+ * @param text $Message to be padded
+ * @param mode $Encryption mode; padding is applied only in CBC or ECB mode
+ * @param block_size $Cipher block size
+ * @param padding_type $Padding scheme
+ */
+ protected function _cryptPadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Removes padding @a padding_type from @a text
+ * If the function detects that the text was not padded, it will return it unmodified
+ *
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ * @param return_value $Result, possibly unpadded
+ * @param text $Message to be unpadded
+ * @param mode $Encryption mode; unpadding is applied only in CBC or ECB mode
+ * @param block_size $Cipher block size
+ * @param padding_type $Padding scheme
+ */
+ protected function _cryptUnpadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Encrypts a text
+ *
+ * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
+ *
+ *
+ * @param string $text
+ * @param string $key
+ * @return string
+ */
+ public function encrypt($text, $key = null) {}
+
+ /**
+ * Decrypts an encrypted text
+ *
+ * echo $crypt->decrypt($encrypted, "decrypt password");
+ *
+ *
+ * @param string $text
+ * @param mixed $key
+ * @return string
+ */
+ public function decrypt($text, $key = null) {}
+
+ /**
+ * Encrypts a text returning the result as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function encryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Decrypt a text that is coded as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function decryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Returns a list of available cyphers
+ *
+ * @return array
+ */
+ public function getAvailableCiphers() {}
+
+ /**
+ * Returns a list of available modes
+ *
+ * @return array
+ */
+ public function getAvailableModes() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/CryptInterface.php b/ide/2.0.5/Phalcon/CryptInterface.php
new file mode 100644
index 000000000..529103de4
--- /dev/null
+++ b/ide/2.0.5/Phalcon/CryptInterface.php
@@ -0,0 +1,107 @@
+
+ * try {
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306',
+ * ));
+ * $result = $connection->query("SELECTFROM robots LIMIT 5");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetch()) {
+ * print_r($robot);
+ * }
+ * } catch (Phalcon\Db\Exception $e) {
+ * echo $e->getMessage(), PHP_EOL;
+ * }
+ *
+ */
+abstract class Db
+{
+
+ const FETCH_LAZY = 1;
+
+
+ const FETCH_ASSOC = 2;
+
+
+ const FETCH_NAMED = 11;
+
+
+ const FETCH_NUM = 3;
+
+
+ const FETCH_BOTH = 4;
+
+
+ const FETCH_OBJ = 5;
+
+
+ const FETCH_BOUND = 6;
+
+
+ const FETCH_COLUMN = 7;
+
+
+ const FETCH_CLASS = 8;
+
+
+ const FETCH_INTO = 9;
+
+
+ const FETCH_FUNC = 10;
+
+
+ const FETCH_GROUP = 65536;
+
+
+ const FETCH_UNIQUE = 196608;
+
+
+ const FETCH_KEY_PAIR = 12;
+
+
+ const FETCH_CLASSTYPE = 262144;
+
+
+ const FETCH_SERIALIZE = 524288;
+
+
+ const FETCH_PROPS_LATE = 1048576;
+
+
+ /**
+ * Enables/disables options in the Database component
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Debug.php b/ide/2.0.5/Phalcon/Debug.php
new file mode 100644
index 000000000..7877c6977
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Debug.php
@@ -0,0 +1,192 @@
+
+ * $di = new \Phalcon\Di();
+ * //Using a string definition
+ * $di->set("request", "Phalcon\Http\Request", true);
+ * //Using an anonymous function
+ * $di->set("request", function(){
+ * return new \Phalcon\Http\Request();
+ * }, true);
+ * $request = $di->getRequest();
+ *
+ */
+class Di implements \Phalcon\DiInterface
+{
+ /**
+ * List of registered services
+ */
+ protected $_services;
+
+ /**
+ * List of shared instances
+ */
+ protected $_sharedInstances;
+
+ /**
+ * To know if the latest resolved instance was shared or not
+ */
+ protected $_freshInstance = false;
+
+ /**
+ * Events Manager
+ *
+ * @var \Phalcon\Events\ManagerInterface
+ */
+ protected $_eventsManager;
+
+ /**
+ * Latest DI build
+ */
+ static protected $_default;
+
+
+ /**
+ * Phalcon\Di constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the internal event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setInternalEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getInternalEventsManager() {}
+
+ /**
+ * Registers a service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function set($name, $definition, $shared = false) {}
+
+ /**
+ * Registers an "always shared" service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setShared($name, $definition) {}
+
+ /**
+ * Removes a service in the services container
+ *
+ * @param string $name
+ */
+ public function remove($name) {}
+
+ /**
+ * Attempts to register a service in the services container
+ * Only is successful if a service hasn"t been registered previously
+ * with the same name
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return bool|\Phalcon\Di\ServiceInterface
+ */
+ public function attempt($name, $definition, $shared = false) {}
+
+ /**
+ * Sets a service using a raw Phalcon\Di\Service definition
+ *
+ * @param string $name
+ * @param mixed $rawDefinition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setRaw($name, \Phalcon\Di\ServiceInterface $rawDefinition) {}
+
+ /**
+ * Returns a service definition without resolving
+ *
+ * @param string $name
+ */
+ public function getRaw($name) {}
+
+ /**
+ * Returns a Phalcon\Di\Service instance
+ *
+ * @param string $name
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function getService($name) {}
+
+ /**
+ * Resolves the service based on its configuration
+ *
+ * @param string $name
+ * @param mixed $parameters
+ */
+ public function get($name, $parameters = null) {}
+
+ /**
+ * Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
+ *
+ * @param string $name
+ * @param array $parameters
+ * @return mixed
+ */
+ public function getShared($name, $parameters = null) {}
+
+ /**
+ * Check whether the DI contains a service by a name
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Check whether the last service obtained via getShared produced a fresh instance or an existing one
+ *
+ * @return bool
+ */
+ public function wasFreshInstance() {}
+
+ /**
+ * Return the services registered in the DI
+ *
+ * @return \Phalcon\Di\Service
+ */
+ public function getServices() {}
+
+ /**
+ * Check if a service is registered using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetExists($name) {}
+
+ /**
+ * Allows to register a shared service using the array syntax
+ *
+ * $di["request"] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return boolean
+ */
+ public function offsetSet($name, $definition) {}
+
+ /**
+ * Allows to obtain a shared service using the array syntax
+ *
+ * var_dump($di["request"]);
+ *
+ *
+ * @param string $name
+ * @return mixed
+ */
+ public function offsetGet($name) {}
+
+ /**
+ * Removes a service from the services container using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetUnset($name) {}
+
+ /**
+ * Magic method to get or set services using setters/getters
+ *
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ public function __call($method, $arguments = null) {}
+
+ /**
+ * Set a default dependency injection container to be obtained into static methods
+ *
+ * @param mixed $dependencyInjector
+ */
+ public static function setDefault(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Return the lastest DI created
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public static function getDefault() {}
+
+ /**
+ * Resets the internal default DI
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/DiInterface.php b/ide/2.0.5/Phalcon/DiInterface.php
new file mode 100644
index 000000000..65bae52fe
--- /dev/null
+++ b/ide/2.0.5/Phalcon/DiInterface.php
@@ -0,0 +1,134 @@
+
+ * $this->dispatcher->forward(array("controller" => "posts", "action" => "index"));
+ *
+ *
+ * @param array $forward
+ */
+ public function forward($forward) {}
+
+ /**
+ * Check if the current executed action was forwarded by another one
+ *
+ * @return bool
+ */
+ public function wasForwarded() {}
+
+ /**
+ * Possible class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getHandlerClass() {}
+
+ /**
+ * Set empty properties to their defaults (where defaults are available)
+ */
+ protected function _resolveEmptyProperties() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/DispatcherInterface.php b/ide/2.0.5/Phalcon/DispatcherInterface.php
new file mode 100644
index 000000000..1b5a292cc
--- /dev/null
+++ b/ide/2.0.5/Phalcon/DispatcherInterface.php
@@ -0,0 +1,120 @@
+
+ * $escaper = new \Phalcon\Escaper();
+ * $escaped = $escaper->escapeCss("font-family:
+ * $escaper->setEncoding('utf-8');
+ *
+ *
+ * @param string $encoding
+ */
+ public function setEncoding($encoding) {}
+
+ /**
+ * Returns the internal encoding used by the escaper
+ *
+ * @return string
+ */
+ public function getEncoding() {}
+
+ /**
+ * Sets the HTML quoting type for htmlspecialchars
+ *
+ * $escaper->setHtmlQuoteType(ENT_XHTML);
+ *
+ *
+ * @param int $quoteType
+ */
+ public function setHtmlQuoteType($quoteType) {}
+
+ /**
+ * Detect the character encoding of a string to be handled by an encoder
+ * Special-handling for chr(172) and chr(128) to chr(159) which fail to be detected by mb_detect_encoding()
+ *
+ * @param string $str
+ * @return string|null
+ */
+ public final function detectEncoding($str) {}
+
+ /**
+ * Utility to normalize a string's encoding to UTF-32.
+ *
+ * @param string $str
+ * @return string
+ */
+ public final function normalizeEncoding($str) {}
+
+ /**
+ * Escapes a HTML string. Internally uses htmlspecialchars
+ *
+ * @param string $text
+ * @return string
+ */
+ public function escapeHtml($text) {}
+
+ /**
+ * Escapes a HTML attribute string
+ *
+ * @param string $attribute
+ * @return string
+ */
+ public function escapeHtmlAttr($attribute) {}
+
+ /**
+ * Escape CSS strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $css
+ * @return string
+ */
+ public function escapeCss($css) {}
+
+ /**
+ * Escape javascript strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $js
+ * @return string
+ */
+ public function escapeJs($js) {}
+
+ /**
+ * Escapes a URL. Internally uses rawurlencode
+ *
+ * @param string $url
+ * @return string
+ */
+ public function escapeUrl($url) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/EscaperInterface.php b/ide/2.0.5/Phalcon/EscaperInterface.php
new file mode 100644
index 000000000..e8718dea2
--- /dev/null
+++ b/ide/2.0.5/Phalcon/EscaperInterface.php
@@ -0,0 +1,73 @@
+
+ * $filter = new \Phalcon\Filter();
+ * $filter->sanitize("some(one)@exa\\mple.com", "email"); // returns "someone@example.com"
+ * $filter->sanitize("hello<<", "string"); // returns "hello"
+ * $filter->sanitize("!100a019", "int"); // returns "100019"
+ * $filter->sanitize("!100a019.01a", "float"); // returns "100019.01"
+ *
+ */
+class Filter implements \Phalcon\FilterInterface
+{
+
+ const FILTER_EMAIL = "email";
+
+
+ const FILTER_ABSINT = "absint";
+
+
+ const FILTER_INT = "int";
+
+
+ const FILTER_INT_CAST = "int!";
+
+
+ const FILTER_STRING = "string";
+
+
+ const FILTER_FLOAT = "float";
+
+
+ const FILTER_FLOAT_CAST = "float!";
+
+
+ const FILTER_ALPHANUM = "alphanum";
+
+
+ const FILTER_TRIM = "trim";
+
+
+ const FILTER_STRIPTAGS = "striptags";
+
+
+ const FILTER_LOWER = "lower";
+
+
+ const FILTER_UPPER = "upper";
+
+
+ protected $_filters;
+
+
+ /**
+ * Adds a user-defined filter
+ *
+ * @param string $name
+ * @param mixed $handler
+ * @return Filter
+ */
+ public function add($name, $handler) {}
+
+ /**
+ * Sanitizes a value with a specified single or set of filters
+ *
+ * @param mixed $value
+ * @param mixed $filters
+ * @param bool $noRecursive
+ */
+ public function sanitize($value, $filters, $noRecursive = false) {}
+
+ /**
+ * Internal sanitize wrapper to filter_var
+ *
+ * @param mixed $value
+ * @param string $filter
+ */
+ protected function _sanitize($value, $filter) {}
+
+ /**
+ * Return the user-defined filters in the instance
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/FilterInterface.php b/ide/2.0.5/Phalcon/FilterInterface.php
new file mode 100644
index 000000000..5ebd2ee21
--- /dev/null
+++ b/ide/2.0.5/Phalcon/FilterInterface.php
@@ -0,0 +1,37 @@
+
+ * $flash->success("The record was successfully deleted");
+ * $flash->error("Cannot open the file");
+ *
+ */
+abstract class Flash
+{
+
+ protected $_cssClasses;
+
+
+ protected $_implicitFlush = true;
+
+
+ protected $_automaticHtml = true;
+
+
+ protected $_messages;
+
+
+ /**
+ * Phalcon\Flash constructor
+ *
+ * @param mixed $cssClasses
+ */
+ public function __construct($cssClasses = null) {}
+
+ /**
+ * Set whether the output must be implicitly flushed to the output or returned as string
+ *
+ * @param bool $implicitFlush
+ * @return \Phalcon\FlashInterface
+ */
+ public function setImplicitFlush($implicitFlush) {}
+
+ /**
+ * Set if the output must be implicitly formatted with HTML
+ *
+ * @param bool $automaticHtml
+ * @return \Phalcon\FlashInterface
+ */
+ public function setAutomaticHtml($automaticHtml) {}
+
+ /**
+ * Set an array with CSS classes to format the messages
+ *
+ * @param array $cssClasses
+ * @return \Phalcon\FlashInterface
+ */
+ public function setCssClasses($cssClasses) {}
+
+ /**
+ * Shows a HTML error message
+ *
+ * $flash->error('This is an error');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function error($message) {}
+
+ /**
+ * Shows a HTML notice/information message
+ *
+ * $flash->notice('This is an information');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function notice($message) {}
+
+ /**
+ * Shows a HTML success message
+ *
+ * $flash->success('The process was finished successfully');
+ *
+ *
+ * @param string $message
+ * @return string
+ */
+ public function success($message) {}
+
+ /**
+ * Shows a HTML warning message
+ *
+ * $flash->warning('Hey, this is important');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function warning($message) {}
+
+ /**
+ * Outputs a message formatting it with HTML
+ *
+ * $flash->outputMessage('error', message);
+ *
+ *
+ * @param string $type
+ * @param string|array $message
+ */
+ public function outputMessage($type, $message) {}
+
+ /**
+ * Clears accumulated messages when implicit flush is disabled
+ */
+ public function clear() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/FlashInterface.php b/ide/2.0.5/Phalcon/FlashInterface.php
new file mode 100644
index 000000000..86ca19753
--- /dev/null
+++ b/ide/2.0.5/Phalcon/FlashInterface.php
@@ -0,0 +1,48 @@
+
+ * //Creates the autoloader
+ * $loader = new Loader();
+ * //Register some namespaces
+ * $loader->registerNamespaces(array(
+ * 'Example\Base' => 'vendor/example/base/',
+ * 'Example\Adapter' => 'vendor/example/adapter/',
+ * 'Example' => 'vendor/example/'
+ * ));
+ * //register autoloader
+ * $loader->register();
+ * //Requiring this class will automatically include file vendor/example/adapter/Some.php
+ * $adapter = Example\Adapter\Some();
+ *
+ */
+class Loader implements \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_eventsManager = null;
+
+
+ protected $_foundPath = null;
+
+
+ protected $_checkedPath = null;
+
+
+ protected $_prefixes = null;
+
+
+ protected $_classes = null;
+
+
+ protected $_extensions;
+
+
+ protected $_namespaces = null;
+
+
+ protected $_directories = null;
+
+
+ protected $_registered = false;
+
+
+ /**
+ * Phalcon\Loader constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the events manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets an array of file extensions that the loader must try in each attempt to locate the file
+ *
+ * @param array $extensions
+ * @return Loader
+ */
+ public function setExtensions($extensions) {}
+
+ /**
+ * Returns the file extensions registered in the loader
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register namespaces and their related directories
+ *
+ * @param array $namespaces
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerNamespaces($namespaces, $merge = false) {}
+
+ /**
+ * Returns the namespaces currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getNamespaces() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $prefixes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerPrefixes($prefixes, $merge = false) {}
+
+ /**
+ * Returns the prefixes currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getPrefixes() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $directories
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerDirs($directories, $merge = false) {}
+
+ /**
+ * Returns the directories currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getDirs() {}
+
+ /**
+ * Register classes and their locations
+ *
+ * @param array $classes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerClasses($classes, $merge = false) {}
+
+ /**
+ * Returns the class-map currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getClasses() {}
+
+ /**
+ * Register the autoload method
+ *
+ * @return Loader
+ */
+ public function register() {}
+
+ /**
+ * Unregister the autoload method
+ *
+ * @return Loader
+ */
+ public function unregister() {}
+
+ /**
+ * Autoloads the registered classes
+ *
+ * @param string $className
+ * @return bool
+ */
+ public function autoLoad($className) {}
+
+ /**
+ * Get the path when a class was found
+ *
+ * @return string
+ */
+ public function getFoundPath() {}
+
+ /**
+ * Get the path the loader is checking for a path
+ *
+ * @return string
+ */
+ public function getCheckedPath() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Logger.php b/ide/2.0.5/Phalcon/Logger.php
new file mode 100644
index 000000000..6ea41067c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Logger.php
@@ -0,0 +1,53 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+abstract class Logger
+{
+
+ const SPECIAL = 9;
+
+
+ const CUSTOM = 8;
+
+
+ const DEBUG = 7;
+
+
+ const INFO = 6;
+
+
+ const NOTICE = 5;
+
+
+ const WARNING = 4;
+
+
+ const ERROR = 3;
+
+
+ const ALERT = 2;
+
+
+ const CRITICAL = 1;
+
+
+ const EMERGENCE = 0;
+
+
+ const EMERGENCY = 0;
+
+
+}
diff --git a/ide/2.0.5/Phalcon/Registry.php b/ide/2.0.5/Phalcon/Registry.php
new file mode 100644
index 000000000..560353724
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Registry.php
@@ -0,0 +1,150 @@
+
+ * $registry = new \Phalcon\Registry();
+ * // Set value
+ * $registry->something = 'something';
+ * // or
+ * $registry['something'] = 'something';
+ * // Get value
+ * $value = $registry->something;
+ * // or
+ * $value = $registry['something'];
+ * // Check if the key exists
+ * $exists = isset($registry->something);
+ * // or
+ * $exists = isset($registry['something']);
+ * // Unset
+ * unset($registry->something);
+ * // or
+ * unset($registry['something']);
+ *
+ * In addition to ArrayAccess, Phalcon\Registry also implements Countable
+ * (count($registry) will return the number of elements in the registry),
+ * Serializable and Iterator (you can iterate over the registry
+ * using a foreach loop) interfaces. For PHP 5.4 and higher, JsonSerializable
+ * interface is implemented.
+ * Phalcon\Registry is very fast (it is typically faster than any userspace
+ * implementation of the registry); however, this comes at a price:
+ * Phalcon\Registry is a final class and cannot be inherited from.
+ * Though Phalcon\Registry exposes methods like __get(), offsetGet(), count() etc,
+ * it is not recommended to invoke them manually (these methods exist mainly to
+ * match the interfaces the registry implements): $registry->__get('property')
+ * is several times slower than $registry->property.
+ * Internally all the magic methods (and interfaces except JsonSerializable)
+ * are implemented using object handlers or similar techniques: this allows
+ * to bypass relatively slow method calls.
+ */
+final class Registry implements \ArrayAccess, \Countable, \Iterator
+{
+
+ protected $_data;
+
+
+ /**
+ * Registry constructor
+ */
+ public final function __construct() {}
+
+ /**
+ * Checks if the element is present in the registry
+ *
+ * @param string $offset
+ * @return bool
+ */
+ public final function offsetExists($offset) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $offset
+ * @return variable
+ */
+ public final function offsetGet($offset) {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $offset
+ * @param mixed $value
+ */
+ public final function offsetSet($offset, $value) {}
+
+ /**
+ * Unsets an element in the registry
+ *
+ * @param string $offset
+ */
+ public final function offsetUnset($offset) {}
+
+ /**
+ * Checks how many elements are in the register
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Moves cursor to next row in the registry
+ */
+ public final function next() {}
+
+ /**
+ * Gets pointer number of active row in the registry
+ *
+ * @return int
+ */
+ public final function key() {}
+
+ /**
+ * Rewinds the registry cursor to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Checks if the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Obtains the current value in the internal iterator
+ */
+ public function current() {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public final function __set($key, $value) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $key
+ * @return variable
+ */
+ public final function __get($key) {}
+
+ /**
+ * @param string $key
+ * @return bool
+ */
+ public final function __isset($key) {}
+
+ /**
+ * @param string $key
+ */
+ public final function __unset($key) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Security.php b/ide/2.0.5/Phalcon/Security.php
new file mode 100644
index 000000000..0a44a9e35
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Security.php
@@ -0,0 +1,201 @@
+
+ * $login = $this->request->getPost('login');
+ * $password = $this->request->getPost('password');
+ * $user = Users::findFirstByLogin($login);
+ * if ($user) {
+ * if ($this->security->checkHash($password, $user->password)) {
+ * //The password is valid
+ * }
+ * }
+ *
+ */
+class Security implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const CRYPT_DEFAULT = 0;
+
+
+ const CRYPT_STD_DES = 1;
+
+
+ const CRYPT_EXT_DES = 2;
+
+
+ const CRYPT_MD5 = 3;
+
+
+ const CRYPT_BLOWFISH = 4;
+
+
+ const CRYPT_BLOWFISH_X = 5;
+
+
+ const CRYPT_BLOWFISH_Y = 6;
+
+
+ const CRYPT_SHA256 = 7;
+
+
+ const CRYPT_SHA512 = 8;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_workFactor = 8;
+
+
+ protected $_numberBytes = 16;
+
+
+ protected $_tokenKeySessionID = "$PHALCON/CSRF/KEY$";
+
+
+ protected $_tokenValueSessionID = "$PHALCON/CSRF$";
+
+
+ protected $_csrf;
+
+
+ protected $_defaultHash;
+
+
+ /**
+ * @param mixed $workFactor
+ */
+ public function setWorkFactor($workFactor) {}
+
+
+ public function getWorkFactor() {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @param long $randomBytes
+ */
+ public function setRandomBytes($randomBytes) {}
+
+ /**
+ * Returns a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @return string
+ */
+ public function getRandomBytes() {}
+
+ /**
+ * Generate a >22-length pseudo random string to be used as salt for passwords
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getSaltBytes($numberBytes = 0) {}
+
+ /**
+ * Creates a password hash using bcrypt with a pseudo random salt
+ *
+ * @param string $password
+ * @param int $workFactor
+ * @return string
+ */
+ public function hash($password, $workFactor = 0) {}
+
+ /**
+ * Checks a plain text password and its hash version to check if the password matches
+ *
+ * @param string $password
+ * @param string $passwordHash
+ * @param int $maxPassLength
+ * @return bool
+ */
+ public function checkHash($password, $passwordHash, $maxPassLength = 0) {}
+
+ /**
+ * Checks if a password hash is a valid bcrypt's hash
+ *
+ * @param string $passwordHash
+ * @return bool
+ */
+ public function isLegacyHash($passwordHash) {}
+
+ /**
+ * Generates a pseudo random token key to be used as input's name in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getTokenKey($numberBytes = null) {}
+
+ /**
+ * Generates a pseudo random token value to be used as input's value in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getToken($numberBytes = null) {}
+
+ /**
+ * Check if the CSRF token sent in the request is the same that the current in session
+ *
+ * @param mixed $tokenKey
+ * @param mixed $tokenValue
+ * @param bool $destroyIfValid
+ * @return bool
+ */
+ public function checkToken($tokenKey = null, $tokenValue = null, $destroyIfValid = true) {}
+
+ /**
+ * Returns the value of the CSRF token in session
+ *
+ * @return string
+ */
+ public function getSessionToken() {}
+
+ /**
+ * Removes the value of the CSRF token and key from session
+ */
+ public function destroyToken() {}
+
+ /**
+ * Computes a HMAC
+ *
+ * @param string $data
+ * @param string $key
+ * @param string $algo
+ * @param boolean $raw
+ */
+ public function computeHmac($data, $key, $algo, $raw = false) {}
+
+ /**
+ * Sets the default hash
+ *
+ * @param mixed $defaultHash
+ */
+ public function setDefaultHash($defaultHash) {}
+
+ /**
+ * Sets the default hash
+ */
+ public function getDefaultHash() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Session.php b/ide/2.0.5/Phalcon/Session.php
new file mode 100644
index 000000000..76e72cff4
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Session.php
@@ -0,0 +1,23 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+abstract class Session
+{
+
+}
diff --git a/ide/2.0.5/Phalcon/Tag.php b/ide/2.0.5/Phalcon/Tag.php
new file mode 100644
index 000000000..ee232b3b2
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Tag.php
@@ -0,0 +1,718 @@
+
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefault("name", "peter");
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function setDefault($id, $value) {}
+
+ /**
+ * Assigns default values to generated tags by helpers
+ *
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefaults(array("name" => "peter"));
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param array $values
+ * @param bool $merge
+ */
+ public static function setDefaults($values, $merge = false) {}
+
+ /**
+ * Alias of Phalcon\Tag::setDefault
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function displayTo($id, $value) {}
+
+ /**
+ * Check if a helper has a default value set using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @return boolean
+ */
+ public static function hasValue($name) {}
+
+ /**
+ * Every helper calls this function to check whether a component has a predefined
+ * value using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @param array $params
+ * @return mixed
+ */
+ public static function getValue($name, $params = null) {}
+
+ /**
+ * Resets the request and internal values to avoid those fields will have any default value
+ */
+ public static function resetInput() {}
+
+ /**
+ * Builds a HTML A tag using framework conventions
+ *
+ * echo Phalcon\Tag::linkTo("signup/register", "Register Here!");
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!"));
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!", "class" => "btn-primary"));
+ * echo Phalcon\Tag::linkTo("http://phalconphp.com/", "Phalcon", FALSE);
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", FALSE));
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", "local" =>FALSE));
+ *
+ *
+ * @param array|string $parameters
+ * @param string $text
+ * @param boolean $local
+ * @return string
+ */
+ public static function linkTo($parameters, $text = null, $local = true) {}
+
+ /**
+ * Builds generic INPUT tags
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @param bool $asValue
+ * @param $boolean asValue
+ * @return string
+ */
+ static protected final function _inputField($type, $parameters, $asValue = false) {}
+
+ /**
+ * Builds INPUT tags that implements the checked attribute
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @return string
+ */
+ static protected final function _inputFieldChecked($type, $parameters) {}
+
+ /**
+ * Builds a HTML input[type="color"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function colorField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="text"] tag
+ *
+ * echo Phalcon\Tag::textField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="number"] tag
+ *
+ * echo Phalcon\Tag::numericField(array("price", "min" => "1", "max" => "5"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function numericField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="range"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function rangeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="email"] tag
+ *
+ * echo Phalcon\Tag::emailField("email");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function emailField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="date"] tag
+ *
+ * echo Phalcon\Tag::dateField(array("born", "value" => "14-12-1980"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function dateField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime-local"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeLocalField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="month"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function monthField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="time"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function timeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="week"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function weekField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="password"] tag
+ *
+ * echo Phalcon\Tag::passwordField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function passwordField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="hidden"] tag
+ *
+ * echo Phalcon\Tag::hiddenField(array("name", "value" => "mike"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function hiddenField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="file"] tag
+ *
+ * echo Phalcon\Tag::fileField("file");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function fileField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="search"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function searchField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="tel"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function telField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="url"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function urlField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="check"] tag
+ *
+ * echo Phalcon\Tag::checkField(array("terms", "value" => "Y"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function checkField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="radio"] tag
+ *
+ * echo Phalcon\Tag::radioField(array("weather", "value" => "hot"))
+ *
+ * Volt syntax:
+ *
+ * {{ radio_field("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function radioField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="image"] tag
+ *
+ * echo Phalcon\Tag::imageInput(array("src" => "/img/button.png"));
+ *
+ * Volt syntax:
+ *
+ * {{ image_input("src": "/img/button.png") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function imageInput($parameters) {}
+
+ /**
+ * Builds a HTML input[type="submit"] tag
+ *
+ * echo Phalcon\Tag::submitButton("Save")
+ *
+ * Volt syntax:
+ *
+ * {{ submit_button("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function submitButton($parameters) {}
+
+ /**
+ * Builds a HTML SELECT tag using a PHP array for options
+ *
+ * echo Phalcon\Tag::selectStatic("status", array("A" => "Active", "I" => "Inactive"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function selectStatic($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML SELECT tag using a Phalcon\Mvc\Model resultset as options
+ *
+ * echo Phalcon\Tag::select(array(
+ * "robotId",
+ * Robots::find("type = "mechanical""),
+ * "using" => array("id", "name")
+ * ));
+ *
+ * Volt syntax:
+ *
+ * {{ select("robotId", robots, "using": ["id", "name"]) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function select($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML TEXTAREA tag
+ *
+ * echo Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4))
+ *
+ * Volt syntax:
+ *
+ * {{ text_area("comments", "cols": 10, "rows": 4) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textArea($parameters) {}
+
+ /**
+ * Builds a HTML FORM tag
+ *
+ * echo Phalcon\Tag::form("posts/save");
+ * echo Phalcon\Tag::form(array("posts/save", "method" => "post"));
+ *
+ * Volt syntax:
+ *
+ * {{ form("posts/save") }}
+ * {{ form("posts/save", "method": "post") }}
+ *
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function form($parameters) {}
+
+ /**
+ * Builds a HTML close FORM tag
+ *
+ * @return string
+ */
+ public static function endForm() {}
+
+ /**
+ * Set the title of view content
+ *
+ * Phalcon\Tag::setTitle("Welcome to my Page");
+ *
+ *
+ * @param string $title
+ */
+ public static function setTitle($title) {}
+
+ /**
+ * Set the title separator of view content
+ *
+ * Phalcon\Tag::setTitleSeparator("-");
+ *
+ *
+ * @param string $titleSeparator
+ */
+ public static function setTitleSeparator($titleSeparator) {}
+
+ /**
+ * Appends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function appendTitle($title) {}
+
+ /**
+ * Prepends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function prependTitle($title) {}
+
+ /**
+ * Gets the current document title
+ *
+ * echo Phalcon\Tag::getTitle();
+ *
+ *
+ * {{ get_title() }}
+ *
+ *
+ * @param bool $tags
+ * @return string
+ */
+ public static function getTitle($tags = true) {}
+
+ /**
+ * Gets the current document title separator
+ *
+ * echo Phalcon\Tag::getTitleSeparator();
+ *
+ *
+ * {{ get_title_separator() }}
+ *
+ *
+ * @return string
+ */
+ public static function getTitleSeparator() {}
+
+ /**
+ * Builds a LINK[rel="stylesheet"] tag
+ *
+ * echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
+ * echo Phalcon\Tag::stylesheetLink("css/style.css");
+ *
+ * Volt Syntax:
+ *
+ * {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }}
+ * {{ stylesheet_link("css/style.css") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function stylesheetLink($parameters = null, $local = true) {}
+
+ /**
+ * Builds a SCRIPT[type="javascript"] tag
+ *
+ * echo Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false);
+ * echo Phalcon\Tag::javascriptInclude("javascript/jquery.js");
+ *
+ * Volt syntax:
+ *
+ * {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false) }}
+ * {{ javascript_include("javascript/jquery.js") }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function javascriptInclude($parameters = null, $local = true) {}
+
+ /**
+ * Builds HTML IMG tags
+ *
+ * echo Phalcon\Tag::image("img/bg.png");
+ * echo Phalcon\Tag::image(array("img/photo.jpg", "alt" => "Some Photo"));
+ *
+ * Volt Syntax:
+ *
+ * {{ image("img/bg.png") }}
+ * {{ image("img/photo.jpg", "alt": "Some Photo") }}
+ * {{ image("http://static.mywebsite.com/img/bg.png", false) }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function image($parameters = null, $local = true) {}
+
+ /**
+ * Converts texts into URL-friendly titles
+ *
+ * echo Phalcon\Tag::friendlyTitle("These are big important news", "-")
+ *
+ *
+ * @param string $text
+ * @param string $separator
+ * @param boolean $lowercase
+ * @param mixed $replace
+ * @return text
+ */
+ public static function friendlyTitle($text, $separator = "-", $lowercase = true, $replace = null) {}
+
+ /**
+ * Set the document type of content
+ *
+ * @param int $doctype
+ */
+ public static function setDocType($doctype) {}
+
+ /**
+ * Get the document type declaration of content
+ *
+ * @return string
+ */
+ public static function getDocType() {}
+
+ /**
+ * Builds a HTML tag
+ *
+ * echo Phalcon\Tag::tagHtml(name, parameters, selfClose, onlyStart, eol);
+ *
+ *
+ * @param string $tagName
+ * @param array $parameters
+ * @param boolean $selfClose
+ * @param boolean $onlyStart
+ * @param boolean $useEol
+ * @return string
+ */
+ public static function tagHtml($tagName, $parameters = null, $selfClose = false, $onlyStart = false, $useEol = false) {}
+
+ /**
+ * Builds a HTML tag closing tag
+ *
+ * echo Phalcon\Tag::tagHtmlClose("script", true)
+ *
+ *
+ * @param string $tagName
+ * @param bool $useEol
+ * @return string
+ */
+ public static function tagHtmlClose($tagName, $useEol = false) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Text.php b/ide/2.0.5/Phalcon/Text.php
new file mode 100644
index 000000000..11c38e0d1
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Text.php
@@ -0,0 +1,171 @@
+
+ * echo Phalcon\Text::camelize('coco_bongo'); //CocoBongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function camelize($str) {}
+
+ /**
+ * Uncamelize strings which are camelized
+ *
+ * echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function uncamelize($str) {}
+
+ /**
+ * Adds a number to a string or increment that number if it already is defined
+ *
+ * echo Phalcon\Text::increment("a"); // "a_1"
+ * echo Phalcon\Text::increment("a_1"); // "a_2"
+ *
+ *
+ * @param string $str
+ * @param mixed $separator
+ * @return string
+ */
+ public static function increment($str, $separator = null) {}
+
+ /**
+ * Generates a random string based on the given type. Type is one of the RANDOM_* constants
+ *
+ * echo Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz"
+ *
+ *
+ * @param int $type
+ * @param long $length
+ * @return string
+ */
+ public static function random($type = 0, $length = 8) {}
+
+ /**
+ * Check if a string starts with a given string
+ *
+ * echo Phalcon\Text::startsWith("Hello", "He"); // true
+ * echo Phalcon\Text::startsWith("Hello", "he", false); // false
+ * echo Phalcon\Text::startsWith("Hello", "he"); // true
+ *
+ *
+ * @param string $str
+ * @param string $start
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function startsWith($str, $start, $ignoreCase = true) {}
+
+ /**
+ * Check if a string ends with a given string
+ *
+ * echo Phalcon\Text::endsWith("Hello", "llo"); // true
+ * echo Phalcon\Text::endsWith("Hello", "LLO", false); // false
+ * echo Phalcon\Text::endsWith("Hello", "LLO"); // true
+ *
+ *
+ * @param string $str
+ * @param string $end
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function endsWith($str, $end, $ignoreCase = true) {}
+
+ /**
+ * Lowercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::lower("HELLO"); // hello
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function lower($str, $encoding = "UTF-8") {}
+
+ /**
+ * Uppercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::upper("hello"); // HELLO
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function upper($str, $encoding = "UTF-8") {}
+
+ /**
+ * Reduces multiple slashes in a string to single slashes
+ *
+ * echo Phalcon\Text::reduceSlashes("foo//bar/baz"); // foo/bar/baz
+ * echo Phalcon\Text::reduceSlashes("http://foo.bar///baz/buz"); // http://foo.bar/baz/buz
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function reduceSlashes($str) {}
+
+ /**
+ * Concatenates strings using the separator only once without duplication in places concatenation
+ *
+ * $str = Phalcon\Text::concat("/", "/tmp/", "/folder_1/", "/folder_2", "folder_3/");
+ * echo $str; // /tmp/folder_1/folder_2/folder_3/
+ *
+ *
+ * @param string $separator
+ * @param string $a
+ * @param string $b
+ * @param string $...N
+ * @return string
+ */
+ public static function concat() {}
+
+ /**
+ * Generates random text in accordance with the template
+ *
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob
+ *
+ *
+ * @param string $text
+ * @param string $leftDelimiter
+ * @param string $rightDelimiter
+ * @param string $separator
+ * @return string
+ */
+ public static function dynamic($text, $leftDelimiter = "{", $rightDelimiter = "}", $separator = "|") {}
+
+}
diff --git a/ide/2.0.5/Phalcon/Translate.php b/ide/2.0.5/Phalcon/Translate.php
new file mode 100644
index 000000000..e0cf39581
--- /dev/null
+++ b/ide/2.0.5/Phalcon/Translate.php
@@ -0,0 +1,13 @@
+
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ */
+ const VERSION_MAJOR = 0;
+
+ /**
+ * The constant referencing the major version. Returns 1
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MEDIUM);
+ *
+ */
+ const VERSION_MEDIUM = 1;
+
+ /**
+ * The constant referencing the major version. Returns 2
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MINOR);
+ *
+ */
+ const VERSION_MINOR = 2;
+
+ /**
+ * The constant referencing the major version. Returns 3
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL);
+ *
+ */
+ const VERSION_SPECIAL = 3;
+
+ /**
+ * The constant referencing the major version. Returns 4
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL_NUMBER);
+ *
+ */
+ const VERSION_SPECIAL_NUMBER = 4;
+
+
+ /**
+ * Area where the version number is set. The format is as follows:
+ * ABBCCDE
+ * A - Major version
+ * B - Med version (two digits)
+ * C - Min version (two digits)
+ * D - Special release: 1 = Alpha, 2 = Beta, 3 = RC, 4 = Stable
+ * E - Special release version i.e. RC1, Beta2 etc.
+ *
+ * @return array
+ */
+ protected static function _getVersion() {}
+
+ /**
+ * Translates a number to a special release
+ * If Special release = 1 this function will return ALPHA
+ *
+ * @param int $special
+ * @return string
+ */
+ protected final static function _getSpecial($special) {}
+
+ /**
+ * Returns the active version (string)
+ *
+ * echo Phalcon\Version::get();
+ *
+ *
+ * @return string
+ */
+ public static function get() {}
+
+ /**
+ * Returns the numeric active version
+ *
+ * echo Phalcon\Version::getId();
+ *
+ *
+ * @return string
+ */
+ public static function getId() {}
+
+ /**
+ * Returns a specific part of the version. If the wrong parameter is passed
+ * it will return the full version
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ *
+ * @param int $part
+ * @return string
+ */
+ public static function getPart($part) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/acl/Adapter.php b/ide/2.0.5/Phalcon/acl/Adapter.php
new file mode 100644
index 000000000..d261e1917
--- /dev/null
+++ b/ide/2.0.5/Phalcon/acl/Adapter.php
@@ -0,0 +1,103 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * $acl->setDefaultAction(Phalcon\Acl::DENY);
+ * //Register roles
+ * $roles = array(
+ * 'users' => new \Phalcon\Acl\Role('Users'),
+ * 'guests' => new \Phalcon\Acl\Role('Guests')
+ * );
+ * foreach ($roles as $role) {
+ * $acl->addRole($role);
+ * }
+ * //Private area resources
+ * $privateResources = array(
+ * 'companies' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'products' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'invoices' => array('index', 'profile')
+ * );
+ * foreach ($privateResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Public area resources
+ * $publicResources = array(
+ * 'index' => array('index'),
+ * 'about' => array('index'),
+ * 'session' => array('index', 'register', 'start', 'end'),
+ * 'contact' => array('index', 'send')
+ * );
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Grant access to public areas to both users and guests
+ * foreach ($roles as $role){
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->allow($role->getName(), $resource, '*');
+ * }
+ * }
+ * //Grant access to private area to role Users
+ * foreach ($privateResources as $resource => $actions) {
+ * foreach ($actions as $action) {
+ * $acl->allow('Users', $resource, $action);
+ * }
+ * }
+ *
+ */
+class Memory extends \Phalcon\Acl\Adapter
+{
+ /**
+ * Roles Names
+ *
+ * @var mixed
+ */
+ protected $_rolesNames;
+
+ /**
+ * Roles
+ *
+ * @var mixed
+ */
+ protected $_roles;
+
+ /**
+ * Resource Names
+ *
+ * @var mixed
+ */
+ protected $_resourcesNames;
+
+ /**
+ * Resources
+ *
+ * @var mixed
+ */
+ protected $_resources;
+
+ /**
+ * Access
+ *
+ * @var mixed
+ */
+ protected $_access;
+
+ /**
+ * Role Inherits
+ *
+ * @var mixed
+ */
+ protected $_roleInherits;
+
+ /**
+ * Access List
+ *
+ * @var mixed
+ */
+ protected $_accessList;
+
+
+ /**
+ * Phalcon\Acl\Adapter\Memory constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Adds a role to the ACL list. Second parameter allows inheriting access data from other existing role
+ * Example:
+ *
+ * $acl->addRole(new Phalcon\Acl\Role('administrator'), 'consultant');
+ * $acl->addRole('administrator', 'consultant');
+ *
+ *
+ * @param mixed $role
+ * @param array|string $accessInherits
+ * @return bool
+ */
+ public function addRole($role, $accessInherits = null) {}
+
+ /**
+ * Do a role inherit from another existing role
+ *
+ * @param string $roleName
+ * @param mixed $roleToInherit
+ * @return bool
+ */
+ public function addInherit($roleName, $roleToInherit) {}
+
+ /**
+ * Check whether role exist in the roles list
+ *
+ * @param string $roleName
+ * @return bool
+ */
+ public function isRole($roleName) {}
+
+ /**
+ * Check whether resource exist in the resources list
+ *
+ * @param string $resourceName
+ * @return bool
+ */
+ public function isResource($resourceName) {}
+
+ /**
+ * Adds a resource to the ACL list
+ * Access names can be a particular action, by example
+ * search, update, delete, etc or a list of them
+ * Example:
+ *
+ * //Add a resource to the the list allowing access to an action
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), 'search');
+ * $acl->addResource('customers', 'search');
+ * //Add a resource with an access list
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), array('create', 'search'));
+ * $acl->addResource('customers', array('create', 'search'));
+ *
+ *
+ * @param \Phalcon\Acl\Resource|string $resourceValue
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResource($resourceValue, $accessList) {}
+
+ /**
+ * Adds access to resources
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Removes an access from a resource
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ */
+ public function dropResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Checks if a role has access to a resource
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ * @param mixed $action
+ */
+ protected function _allowOrDeny($roleName, $resourceName, $access, $action) {}
+
+ /**
+ * Allow access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Allow access to guests to search on customers
+ * $acl->allow('guests', 'customers', 'search');
+ * //Allow access to guests to search or create on customers
+ * $acl->allow('guests', 'customers', array('search', 'create'));
+ * //Allow access to any role to browse on products
+ * $acl->allow('*', 'products', 'browse');
+ * //Allow access to any role to browse on any resource
+ * $acl->allow('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function allow($roleName, $resourceName, $access) {}
+
+ /**
+ * Deny access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Deny access to guests to search on customers
+ * $acl->deny('guests', 'customers', 'search');
+ * //Deny access to guests to search or create on customers
+ * $acl->deny('guests', 'customers', array('search', 'create'));
+ * //Deny access to any role to browse on products
+ * $acl->deny('*', 'products', 'browse');
+ * //Deny access to any role to browse on any resource
+ * $acl->deny('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function deny($roleName, $resourceName, $access) {}
+
+ /**
+ * Check whether a role is allowed to access an action from a resource
+ *
+ * //Does andres have access to the customers resource to create?
+ * $acl->isAllowed('andres', 'Products', 'create');
+ * //Do guests have access to any resource to edit?
+ * $acl->isAllowed('guests', '*', 'edit');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param string $access
+ * @return bool
+ */
+ public function isAllowed($roleName, $resourceName, $access) {}
+
+ /**
+ * Return an array with every role registered in the list
+ *
+ * @return \Phalcon\Acl\Role
+ */
+ public function getRoles() {}
+
+ /**
+ * Return an array with every resource registered in the list
+ *
+ * @return \Phalcon\Acl\Resource
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/annotations/Adapter.php b/ide/2.0.5/Phalcon/annotations/Adapter.php
new file mode 100644
index 000000000..19b67c0aa
--- /dev/null
+++ b/ide/2.0.5/Phalcon/annotations/Adapter.php
@@ -0,0 +1,74 @@
+
+ * //Traverse annotations
+ * foreach ($classAnnotations as $annotation) {
+ * echo 'Name=', $annotation->getName(), PHP_EOL;
+ * }
+ * //Check if the annotations has a specific
+ * var_dump($classAnnotations->has('Cacheable'));
+ * //Get an specific annotation in the collection
+ * $annotation = $classAnnotations->get('Cacheable');
+ *
+ */
+class Collection implements \Iterator, \Countable
+{
+
+ protected $_position = 0;
+
+
+ protected $_annotations;
+
+
+ /**
+ * Phalcon\Annotations\Collection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the number of annotations in the collection
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current annotation in the iterator
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current annotation in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Returns the internal annotations as an array
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAnnotations() {}
+
+ /**
+ * Returns the first annotation that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function get($name) {}
+
+ /**
+ * Returns all the annotations that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAll($name) {}
+
+ /**
+ * Check if an annotation exists in a collection
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/annotations/Exception.php b/ide/2.0.5/Phalcon/annotations/Exception.php
new file mode 100644
index 000000000..973db2530
--- /dev/null
+++ b/ide/2.0.5/Phalcon/annotations/Exception.php
@@ -0,0 +1,9 @@
+
+ * use Phalcon\Annotations\Reader;
+ * use Phalcon\Annotations\Reflection;
+ * // Parse the annotations in a class
+ * $reader = new Reader();
+ * $parsing = reader->parse('MyComponent');
+ * // Create the reflection
+ * $reflection = new Reflection($parsing);
+ * // Get the annotations in the class docblock
+ * $classAnnotations = reflection->getClassAnnotations();
+ *
+ */
+class Reflection
+{
+
+ protected $_reflectionData;
+
+
+ protected $_classAnnotations;
+
+
+ protected $_methodAnnotations;
+
+
+ protected $_propertyAnnotations;
+
+
+ /**
+ * Phalcon\Annotations\Reflection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the annotations found in the class docblock
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getClassAnnotations() {}
+
+ /**
+ * Returns the annotations found in the methods' docblocks
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getMethodsAnnotations() {}
+
+ /**
+ * Returns the annotations found in the properties' docblocks
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getPropertiesAnnotations() {}
+
+ /**
+ * Returns the raw parsing intermediate definitions used to construct the reflection
+ *
+ * @return array
+ */
+ public function getReflectionData() {}
+
+ /**
+ * Restores the state of a Phalcon\Annotations\Reflection variable export
+ *
+ * @param mixed $data
+ * @return array
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/annotations/adapter/Apc.php b/ide/2.0.5/Phalcon/annotations/adapter/Apc.php
new file mode 100644
index 000000000..822c0c8a8
--- /dev/null
+++ b/ide/2.0.5/Phalcon/annotations/adapter/Apc.php
@@ -0,0 +1,44 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Apc();
+ *
+ */
+class Apc extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from APC
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/annotations/adapter/Files.php b/ide/2.0.5/Phalcon/annotations/adapter/Files.php
new file mode 100644
index 000000000..9115c2b35
--- /dev/null
+++ b/ide/2.0.5/Phalcon/annotations/adapter/Files.php
@@ -0,0 +1,43 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Files(array(
+ * 'annotationsDir' => 'app/cache/annotations/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_annotationsDir = "./";
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from files
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to files
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/annotations/adapter/Memory.php b/ide/2.0.5/Phalcon/annotations/adapter/Memory.php
new file mode 100644
index 000000000..84ad80c8c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/annotations/adapter/Memory.php
@@ -0,0 +1,35 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Xcache();
+ *
+ */
+class Xcache extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ /**
+ * Reads parsed annotations from XCache
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to XCache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/assets/Collection.php b/ide/2.0.5/Phalcon/assets/Collection.php
new file mode 100644
index 000000000..5895735fb
--- /dev/null
+++ b/ide/2.0.5/Phalcon/assets/Collection.php
@@ -0,0 +1,271 @@
+
+ * $inline = new \Phalcon\Assets\Inline('js', 'alert("hello world");');
+ *
+ */
+class Inline
+{
+
+ protected $_type;
+
+
+ protected $_content;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+
+ public function getType() {}
+
+
+ public function getContent() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+ /**
+ * Phalcon\Assets\Inline constructor
+ *
+ * @param string $type
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $content, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the inline's type
+ *
+ * @param string $type
+ * @return Inline
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Inline
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Inline
+ */
+ public function setAttributes($attributes) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/assets/Manager.php b/ide/2.0.5/Phalcon/assets/Manager.php
new file mode 100644
index 000000000..b2c0e7625
--- /dev/null
+++ b/ide/2.0.5/Phalcon/assets/Manager.php
@@ -0,0 +1,242 @@
+
+ * $assets->addCss('css/bootstrap.css');
+ * $assets->addCss('http://bootstrap.my-cdn.com/style.css', false);
+ *
+ *
+ * @param string $path
+ * @param mixed $local
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addCss($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline Css to the 'css' collection
+ *
+ * @param string $content
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addInlineCss($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a javascript resource to the 'js' collection
+ *
+ * $assets->addJs('scripts/jquery.js');
+ * $assets->addJs('http://jquery.my-cdn.com/jquery.js', false);
+ *
+ *
+ * @param string $path
+ * @param mixed $local
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addJs($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline javascript to the 'js' collection
+ *
+ * @param string $content
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addInlineJs($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a resource by its type
+ *
+ * $assets->addResourceByType('css', new \Phalcon\Assets\Resource\Css('css/style.css'));
+ *
+ *
+ * @param string $type
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResourceByType($type, \Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a inline code by its type
+ *
+ * @param string $type
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCodeByType($type, Inline $code) {}
+
+ /**
+ * Adds a raw resource to the manager
+ *
+ * $assets->addResource(new Phalcon\Assets\Resource('css', 'css/style.css'));
+ *
+ *
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResource(\Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a raw inline code to the manager
+ *
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCode(Inline $code) {}
+
+ /**
+ * Sets a collection in the Assets Manager
+ *
+ * $assets->set('js', $collection);
+ *
+ *
+ * @param string $id
+ * @param mixed $collection
+ * @return Manager
+ */
+ public function set($id, \Phalcon\Assets\Collection $collection) {}
+
+ /**
+ * Returns a collection by its id
+ *
+ * $scripts = $assets->get('js');
+ *
+ *
+ * @param string $id
+ * @return \Phalcon\Assets\Collection
+ */
+ public function get($id) {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getCss() {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getJs() {}
+
+ /**
+ * Creates/Returns a collection of resources
+ *
+ * @param string $name
+ * @return \Phalcon\Assets\Collection
+ */
+ public function collection($name) {}
+
+ /**
+ * Traverses a collection calling the callback to generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param callback $callback
+ * @param string $type
+ */
+ public function output(\Phalcon\Assets\Collection $collection, $callback, $type) {}
+
+ /**
+ * Traverses a collection and generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param string $type
+ */
+ public function outputInline(\Phalcon\Assets\Collection $collection, $type) {}
+
+ /**
+ * Prints the HTML for CSS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline CSS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for JS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputJs($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline JS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineJs($collectionName = null) {}
+
+ /**
+ * Returns existing collections in the manager
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getCollections() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/assets/Resource.php b/ide/2.0.5/Phalcon/assets/Resource.php
new file mode 100644
index 000000000..e2013640d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/assets/Resource.php
@@ -0,0 +1,170 @@
+
+ * $resource = new \Phalcon\Assets\Resource('js', 'javascripts/jquery.js');
+ *
+ */
+class Resource
+{
+
+ protected $_type;
+
+
+ protected $_path;
+
+
+ protected $_local;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+ protected $_sourcePath;
+
+
+ protected $_targetPath;
+
+
+ protected $_targetUri;
+
+
+
+ public function getType() {}
+
+
+ public function getPath() {}
+
+
+ public function getLocal() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+
+ public function getSourcePath() {}
+
+
+ public function getTargetPath() {}
+
+
+ public function getTargetUri() {}
+
+ /**
+ * Phalcon\Assets\Resource constructor
+ *
+ * @param string $type
+ * @param string $path
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the resource's type
+ *
+ * @param string $type
+ * @return Resource
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets the resource's path
+ *
+ * @param string $path
+ * @return Resource
+ */
+ public function setPath($path) {}
+
+ /**
+ * Sets if the resource is local or external
+ *
+ * @param bool $local
+ * @return Resource
+ */
+ public function setLocal($local) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Resource
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Resource
+ */
+ public function setAttributes($attributes) {}
+
+ /**
+ * Sets a target uri for the generated HTML
+ *
+ * @param string $targetUri
+ * @return Resource
+ */
+ public function setTargetUri($targetUri) {}
+
+ /**
+ * Sets the resource's source path
+ *
+ * @param string $sourcePath
+ * @return Resource
+ */
+ public function setSourcePath($sourcePath) {}
+
+ /**
+ * Sets the resource's target path
+ *
+ * @param string $targetPath
+ * @return Resource
+ */
+ public function setTargetPath($targetPath) {}
+
+ /**
+ * Returns the content of the resource as an string
+ * Optionally a base path where the resource is located can be set
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getContent($basePath = null) {}
+
+ /**
+ * Returns the real target uri for the generated HTML
+ *
+ * @return string
+ */
+ public function getRealTargetUri() {}
+
+ /**
+ * Returns the complete location where the resource is located
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealSourcePath($basePath = null) {}
+
+ /**
+ * Returns the complete location where the resource must be written
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealTargetPath($basePath = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/assets/filters/Cssmin.php b/ide/2.0.5/Phalcon/assets/filters/Cssmin.php
new file mode 100644
index 000000000..7071441f5
--- /dev/null
+++ b/ide/2.0.5/Phalcon/assets/filters/Cssmin.php
@@ -0,0 +1,22 @@
+
+ * use Phalcon\Cache\Frontend\Data as DataFrontend,
+ * Phalcon\Cache\Multiple,
+ * Phalcon\Cache\Backend\Apc as ApcCache,
+ * Phalcon\Cache\Backend\Memcache as MemcacheCache,
+ * Phalcon\Cache\Backend\File as FileCache;
+ * $ultraFastFrontend = new DataFrontend(array(
+ * "lifetime" => 3600
+ * ));
+ * $fastFrontend = new DataFrontend(array(
+ * "lifetime" => 86400
+ * ));
+ * $slowFrontend = new DataFrontend(array(
+ * "lifetime" => 604800
+ * ));
+ * //Backends are registered from the fastest to the slower
+ * $cache = new Multiple(array(
+ * new ApcCache($ultraFastFrontend, array(
+ * "prefix" => 'cache',
+ * )),
+ * new MemcacheCache($fastFrontend, array(
+ * "prefix" => 'cache',
+ * "host" => "localhost",
+ * "port" => "11211"
+ * )),
+ * new FileCache($slowFrontend, array(
+ * "prefix" => 'cache',
+ * "cacheDir" => "../app/cache/"
+ * ))
+ * ));
+ * //Save, saves in every backend
+ * $cache->save('my-key', $data);
+ *
+ */
+class Multiple
+{
+
+ protected $_backends;
+
+
+ /**
+ * Phalcon\Cache\Multiple constructor
+ *
+ * @param Phalcon\Cache\BackendInterface[] backends
+ * @param mixed $backends
+ */
+ public function __construct($backends = null) {}
+
+ /**
+ * Adds a backend
+ *
+ * @param mixed $backend
+ * @return Multiple
+ */
+ public function push(\Phalcon\Cache\BackendInterface $backend) {}
+
+ /**
+ * Returns a cached content reading the internal backends
+ *
+ * @param mixed $keyName
+ * @param long $lifetime
+ * @param $string|int keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Starts every backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ */
+ public function start($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into all backends and stops the frontend
+ *
+ * @param string $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = null) {}
+
+ /**
+ * Deletes a value from each backend
+ *
+ * @param string|int $keyName
+ * @return boolean
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Checks if cache exists in at least one backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/cache/backend/Apc.php b/ide/2.0.5/Phalcon/cache/backend/Apc.php
new file mode 100644
index 000000000..8e6f53d83
--- /dev/null
+++ b/ide/2.0.5/Phalcon/cache/backend/Apc.php
@@ -0,0 +1,95 @@
+
+ * //Cache data for 2 days
+ * $frontCache = new \Phalcon\Cache\Frontend\Data(array(
+ * 'lifetime' => 172800
+ * ));
+ * $cache = new \Phalcon\Cache\Backend\Apc($frontCache, array(
+ * 'prefix' => 'app-data'
+ * ));
+ * //Cache arbitrary data
+ * $cache->save('my-data', array(1, 2, 3, 4, 5));
+ * //Get data
+ * $data = $cache->get('my-data');
+ *
+ */
+class Apc extends \Phalcon\Cache\Backend implements \Phalcon\Cache\BackendInterface
+{
+
+ /**
+ * Returns a cached content
+ *
+ * @param string $keyName
+ * @param long $lifetime
+ * @param $string|long keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into the APC backend and stops the frontend
+ *
+ * @param string|long $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = true) {}
+
+ /**
+ * Increment of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function increment($keyName = null, $value = 1) {}
+
+ /**
+ * Decrement of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function decrement($keyName = null, $value = 1) {}
+
+ /**
+ * Deletes a value from the cache by its key
+ *
+ * @param string $keyName
+ * @return bool
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Query the existing cached keys
+ *
+ * @param string $prefix
+ * @return array
+ */
+ public function queryKeys($prefix = null) {}
+
+ /**
+ * Checks if cache exists and it hasn't expired
+ *
+ * @param string|long $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+ /**
+ * Immediately invalidates all existing items.
+ *
+ * @return bool
+ */
+ public function flush() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/cache/backend/File.php b/ide/2.0.5/Phalcon/cache/backend/File.php
new file mode 100644
index 000000000..44e4a87c0
--- /dev/null
+++ b/ide/2.0.5/Phalcon/cache/backend/File.php
@@ -0,0 +1,135 @@
+
+ * //Cache the file for 2 days
+ * $frontendOptions = array(
+ * 'lifetime' => 172800
+ * );
+ * //Create a output cache
+ * $frontCache = \Phalcon\Cache\Frontend\Output($frontOptions);
+ * //Set the cache directory
+ * $backendOptions = array(
+ * 'cacheDir' => '../app/cache/'
+ * );
+ * //Create the File backend
+ * $cache = new \Phalcon\Cache\Backend\File($frontCache, $backendOptions);
+ * $content = $cache->start('my-cache');
+ * if ($content === null) {
+ * echo '
+ * application->addModules(array(
+ * 'admin' => array(
+ * 'className' => 'Multiple\Admin\Module',
+ * 'path' => '../apps/admin/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ */
+ public function addModules($modules) {}
+
+ /**
+ * Return the modules registered in the console
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Handle the whole command-line tasks
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Set an specific argument
+ *
+ * @param array $arguments
+ * @param bool $str
+ * @param bool $shift
+ * @return Console
+ */
+ public function setArgument($arguments = null, $str = true, $shift = true) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/cli/Dispatcher.php b/ide/2.0.5/Phalcon/cli/Dispatcher.php
new file mode 100644
index 000000000..9af6c4e3f
--- /dev/null
+++ b/ide/2.0.5/Phalcon/cli/Dispatcher.php
@@ -0,0 +1,111 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Cli\Dispatcher();
+ * $dispatcher->setDi(di);
+ * $dispatcher->setTaskName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $handle = dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher
+{
+
+ protected $_handlerSuffix = "Task";
+
+
+ protected $_defaultHandler = "main";
+
+
+ protected $_defaultAction = "main";
+
+
+ protected $_options;
+
+
+ /**
+ * Phalcon\Cli\Dispatcher constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the default task suffix
+ *
+ * @param string $taskSuffix
+ */
+ public function setTaskSuffix($taskSuffix) {}
+
+ /**
+ * Sets the default task name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the task name to be dispatched
+ *
+ * @param string $taskName
+ */
+ public function setTaskName($taskName) {}
+
+ /**
+ * Gets last dispatched task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getLastTask() {}
+
+ /**
+ * Returns the active task in the dispatcher
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getActiveTask() {}
+
+ /**
+ * Set the options to be dispatched
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get dispatched options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/cli/Router.php b/ide/2.0.5/Phalcon/cli/Router.php
new file mode 100644
index 000000000..57c6a3f88
--- /dev/null
+++ b/ide/2.0.5/Phalcon/cli/Router.php
@@ -0,0 +1,211 @@
+Phalcon\Cli\Router is the standard framework router. Routing is the
+ * process of taking a command-line arguments and
+ * decomposing it into parameters to determine which module, task, and
+ * action of that task should receive the request
+ *
+ * $router = new \Phalcon\Cli\Router();
+ * $router->handle(array(
+ * 'module' => 'main',
+ * 'task' => 'videos',
+ * 'action' => 'process'
+ * ));
+ * echo $router->getTaskName();
+ *
+ */
+class Router implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_module;
+
+
+ protected $_task;
+
+
+ protected $_action;
+
+
+ protected $_params;
+
+
+ protected $_defaultModule = null;
+
+
+ protected $_defaultTask = null;
+
+
+ protected $_defaultAction = null;
+
+
+ protected $_defaultParams;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ /**
+ * Phalcon\Cli\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return Router
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Handles routing information received from command-line arguments
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Adds a route to the router
+ *
+ * $router->add('/about', 'About::main');
+ *
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function add($pattern, $paths = null) {}
+
+ /**
+ * Returns proccesed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns proccesed task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Returns proccesed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns proccesed extra params
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param int $id
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Cli\Router\Route
+ */
+ public function getRouteByName($name) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/cli/Task.php b/ide/2.0.5/Phalcon/cli/Task.php
new file mode 100644
index 000000000..5a8d068e5
--- /dev/null
+++ b/ide/2.0.5/Phalcon/cli/Task.php
@@ -0,0 +1,31 @@
+
+ * class HelloTask extends \Phalcon\Cli\Task
+ * {
+ * //This action will be executed by default
+ * public function mainAction()
+ * {
+ * }
+ * public function findAction()
+ * {
+ * }
+ * }
+ *
+ */
+class Task extends \Phalcon\Di\Injectable
+{
+
+ /**
+ * Phalcon\Cli\Task constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/cli/console/Exception.php b/ide/2.0.5/Phalcon/cli/console/Exception.php
new file mode 100644
index 000000000..91718714c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/cli/console/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callback $callback
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return mixed
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param callable $converter
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+ /**
+ * Set the routing delimiter
+ *
+ * @param string $delimiter
+ */
+ public static function delimiter($delimiter = null) {}
+
+ /**
+ * Get routing delimiter
+ *
+ * @return string
+ */
+ public static function getDelimiter() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/config/Exception.php b/ide/2.0.5/Phalcon/config/Exception.php
new file mode 100644
index 000000000..a6f27ac66
--- /dev/null
+++ b/ide/2.0.5/Phalcon/config/Exception.php
@@ -0,0 +1,12 @@
+
+ * [database]
+ * adapter = Mysql
+ * host = localhost
+ * username = scott
+ * password = cheetah
+ * dbname = test_db
+ * [phalcon]
+ * controllersDir = "../app/controllers/"
+ * modelsDir = "../app/models/"
+ * viewsDir = "../app/views/"
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Ini("path/config.ini");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Ini extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Ini constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+ /**
+ * Build multidimensional array from string
+ *
+ * $this->_parseIniString('path.hello.world', 'value for last key');
+ * // result
+ * [
+ * 'path' => [
+ * 'hello' => [
+ * 'world' => 'value for last key',
+ * ],
+ * ],
+ * ];
+ *
+ *
+ * @param string $path
+ * @param mixed $value
+ * @return array
+ */
+ protected function _parseIniString($path, $value) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/config/adapter/Json.php b/ide/2.0.5/Phalcon/config/adapter/Json.php
new file mode 100644
index 000000000..5ee81e9f3
--- /dev/null
+++ b/ide/2.0.5/Phalcon/config/adapter/Json.php
@@ -0,0 +1,29 @@
+
+ * {"phalcon":{"baseuri":"\/phalcon\/"},"models":{"metadata":"memory"}}
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Json("path/config.json");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Json extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Json constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/config/adapter/Php.php b/ide/2.0.5/Phalcon/config/adapter/Php.php
new file mode 100644
index 000000000..1627f9246
--- /dev/null
+++ b/ide/2.0.5/Phalcon/config/adapter/Php.php
@@ -0,0 +1,42 @@
+
+ * array(
+ * 'adapter' => 'Mysql',
+ * 'host' => 'localhost',
+ * 'username' => 'scott',
+ * 'password' => 'cheetah',
+ * 'dbname' => 'test_db'
+ * ),
+ * 'phalcon' => array(
+ * 'controllersDir' => '../app/controllers/',
+ * 'modelsDir' => '../app/models/',
+ * 'viewsDir' => '../app/views/'
+ * ));
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Php("path/config.php");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Php extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Php constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/config/adapter/Yaml.php b/ide/2.0.5/Phalcon/config/adapter/Yaml.php
new file mode 100644
index 000000000..d9f5a9fe5
--- /dev/null
+++ b/ide/2.0.5/Phalcon/config/adapter/Yaml.php
@@ -0,0 +1,34 @@
+
+ * phalcon
+ * baseuri: /phalcon/
+ * models:
+ * metadata: memory
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Yaml("path/config.yaml");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Yaml extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Yaml constructor
+ *
+ * @throws \Phalcon\Config\Exception
+ * @param string $filePath
+ * @param array $callbacks
+ */
+ public function __construct($filePath, $callbacks = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/crypt/Exception.php b/ide/2.0.5/Phalcon/crypt/Exception.php
new file mode 100644
index 000000000..5af7d614f
--- /dev/null
+++ b/ide/2.0.5/Phalcon/crypt/Exception.php
@@ -0,0 +1,12 @@
+
+ * //Getting first robot
+ * $robot = $connection->fecthOne("SELECTFROM robots");
+ * print_r($robot);
+ * //Getting first robot with associative indexes only
+ * $robot = $connection->fecthOne("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $fetchMode
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return array
+ */
+ public function fetchOne($sqlQuery, $fetchMode = Db::FETCH_ASSOC, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Dumps the complete result of a query into an array
+ *
+ * //Getting all robots with associative indexes only
+ * $robots = $connection->fetchAll("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * foreach ($robots as $robot) {
+ * print_r($robot);
+ * }
+ * //Getting all robots that contains word "robot" withing the name
+ * $robots = $connection->fetchAll("SELECTFROM robots WHERE name LIKE :name",
+ * Phalcon\Db::FETCH_ASSOC,
+ * array('name' => '%robot%')
+ * );
+ * foreach($robots as $robot){
+ * print_r($robot);
+ * }
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $fetchMode
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return array
+ */
+ public function fetchAll($sqlQuery, $fetchMode = Db::FETCH_ASSOC, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Returns the n'th field of first row in a SQL query result
+ *
+ * //Getting count of robots
+ * $robotsCount = $connection->fetchColumn("SELECT count(*) FROM robots");
+ * print_r($robotsCount);
+ * //Getting name of last edited robot
+ * $robot = $connection->fetchColumn("SELECT id, name FROM robots order by modified desc", 1);
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param array $placeholders
+ * @param int|string $column
+ * @return string|
+ */
+ public function fetchColumn($sqlQuery, $placeholders = null, $column = 0) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ *
+ * // Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * // Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param string|array $table
+ * @param array $values
+ * @param mixed $fields
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @return
+ */
+ public function insert($table, $values, $fields = null, $dataTypes = null) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ *
+ * //Inserting a new robot
+ * $success = $connection->insertAsDict(
+ * "robots",
+ * array(
+ * "name" => "Astro Boy",
+ * "year" => 1952
+ * )
+ * );
+ * //Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $dataTypes
+ * @param $string table
+ * @param $array dataTypes
+ * @return
+ */
+ public function insertAsDict($table, $data, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ * //Updating existing robot with array condition and $dataTypes
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * array(
+ * 'conditions' => "id = ?",
+ * 'bind' => array($some_unsafe_id),
+ * 'bindTypes' => array(PDO::PARAM_INT) //use only if you use $dataTypes param
+ * ),
+ * array(PDO::PARAM_STR)
+ * );
+ *
+ * Warning! If $whereCondition is string it not escaped.
+ *
+ * @param string|array $table
+ * @param mixed $fields
+ * @param mixed $values
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @param $string|array whereCondition
+ * @return
+ */
+ public function update($table, $fields, $values, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ * Another, more convenient syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array(
+ * "name" => "New Astro Boy"
+ * ),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $string whereCondition
+ * @param $array dataTypes
+ * @return
+ */
+ public function updateAsDict($table, $data, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Deletes data from a table using custom RBDM SQL syntax
+ *
+ * //Deleting existing robot
+ * $success = $connection->delete(
+ * "robots",
+ * "id = 101"
+ * );
+ * //Next SQL sentence is generated
+ * DELETE FROM `robots` WHERE `id` = 101
+ *
+ *
+ * @param string|array $table
+ * @param string $whereCondition
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return boolean
+ */
+ public function delete($table, $whereCondition = null, $placeholders = null, $dataTypes = null) {}
+
+ /**
+ * Gets a list of columns
+ *
+ * @param array columnList
+ * @return string
+ * @param mixed $columnList
+ * @return string
+ */
+ public function getColumnList($columnList) {}
+
+ /**
+ * Appends a LIMIT clause to $sqlQuery argument
+ *
+ * echo $connection->limit("SELECTFROM robots", 5);
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.table
+ *
+ * var_dump($connection->tableExists("blog", "posts"));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * var_dump($connection->viewExists("active_users", "posts"));
+ *
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Drops a table from a schema/database
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropTable($tableName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Creates a view
+ *
+ * @param string tableName
+ * @param array definition
+ * @param string schemaName
+ * @return boolean
+ * @param string $viewName
+ * @param array $definition
+ * @param mixed $schemaName
+ * @return bool
+ */
+ public function createView($viewName, $definition, $schemaName = null) {}
+
+ /**
+ * Drops a view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropView($viewName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Adds a column to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @return bool
+ */
+ public function addColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Drops a column from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $columnName
+ * @return bool
+ */
+ public function dropColumn($tableName, $schemaName, $columnName) {}
+
+ /**
+ * Adds an index to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addIndex($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drop an index from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $indexName
+ * @return bool
+ */
+ public function dropIndex($tableName, $schemaName, $indexName) {}
+
+ /**
+ * Adds a primary key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addPrimaryKey($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drops a table's primary key
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function dropPrimaryKey($tableName, $schemaName) {}
+
+ /**
+ * Adds a foreign key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $reference
+ * @return bool
+ */
+ public function addForeignKey($tableName, $schemaName, ReferenceInterface $reference) {}
+
+ /**
+ * Drops a foreign key from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $referenceName
+ * @return bool
+ */
+ public function dropForeignKey($tableName, $schemaName, $referenceName) {}
+
+ /**
+ * Returns the SQL column definition from a column
+ *
+ * @param mixed $column
+ * @return string
+ */
+ public function getColumnDefinition(\Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * List all tables on a database
+ *
+ * print_r($connection->listTables("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * List all views on a database
+ *
+ * print_r($connection->listViews("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * print_r($connection->describeIndexes('robots_parts'));
+ *
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\Index[]
+ * @param string $table
+ * @param mixed $schema
+ * @return Index
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * print_r($connection->describeReferences('robots_parts'));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return Reference
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Gets creation options from a table
+ *
+ * print_r($connection->tableOptions('robots'));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return array
+ */
+ public function tableOptions($tableName, $schemaName = null) {}
+
+ /**
+ * Creates a new savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Releases given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Rollbacks given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Set if nested transactions should use savepoints
+ *
+ * @param bool $nestedTransactionsWithSavepoints
+ * @return AdapterInterface
+ */
+ public function setNestedTransactionsWithSavepoints($nestedTransactionsWithSavepoints) {}
+
+ /**
+ * Returns if nested transactions should use savepoints
+ *
+ * @return bool
+ */
+ public function isNestedTransactionsWithSavepoints() {}
+
+ /**
+ * Returns the savepoint name to use for nested transactions
+ *
+ * @return string
+ */
+ public function getNestedTransactionSavepointName() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Returns the default value to make the RBDM use the default value declared in the table definition
+ *
+ * //Inserting a new robot with a valid default value for the column 'year'
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", $connection->getDefaultValue()),
+ * array("name", "year")
+ * );
+ *
+ *
+ * @return RawValue
+ */
+ public function getDefaultValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return descriptor used to connect to the active database
+ *
+ * @return array
+ */
+ public function getDescriptor() {}
+
+ /**
+ * Gets the active connection unique identifier
+ *
+ * @return string
+ */
+ public function getConnectionId() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return string
+ */
+ public function getSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object without replace bound paramters
+ *
+ * @return string
+ */
+ public function getRealSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return array
+ */
+ public function getSQLBindTypes() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/AdapterInterface.php b/ide/2.0.5/Phalcon/db/AdapterInterface.php
new file mode 100644
index 000000000..7726f24de
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/AdapterInterface.php
@@ -0,0 +1,559 @@
+
+ * use Phalcon\Db\Column as Column;
+ * //column definition
+ * $column = new Column("id", array(
+ * "type" => Column::TYPE_INTEGER,
+ * "size" => 10,
+ * "unsigned" => true,
+ * "notNull" => true,
+ * "autoIncrement" => true,
+ * "first" => true
+ * ));
+ * //add column to existing table
+ * $connection->addColumn("robots", null, $column);
+ *
+ */
+class Column implements \Phalcon\Db\ColumnInterface
+{
+ /**
+ * Integer abstract type
+ */
+ const TYPE_INTEGER = 0;
+
+ /**
+ * Date abstract type
+ */
+ const TYPE_DATE = 1;
+
+ /**
+ * Varchar abstract type
+ */
+ const TYPE_VARCHAR = 2;
+
+ /**
+ * Decimal abstract type
+ */
+ const TYPE_DECIMAL = 3;
+
+ /**
+ * Datetime abstract type
+ */
+ const TYPE_DATETIME = 4;
+
+ /**
+ * Char abstract type
+ */
+ const TYPE_CHAR = 5;
+
+ /**
+ * Text abstract data type
+ */
+ const TYPE_TEXT = 6;
+
+ /**
+ * Float abstract data type
+ */
+ const TYPE_FLOAT = 7;
+
+ /**
+ * Boolean abstract data type
+ */
+ const TYPE_BOOLEAN = 8;
+
+ /**
+ * Double abstract data type
+ */
+ const TYPE_DOUBLE = 9;
+
+ /**
+ * Tinyblob abstract data type
+ */
+ const TYPE_TINYBLOB = 10;
+
+ /**
+ * Blob abstract data type
+ */
+ const TYPE_BLOB = 11;
+
+ /**
+ * Mediumblob abstract data type
+ */
+ const TYPE_MEDIUMBLOB = 12;
+
+ /**
+ * Longblob abstract data type
+ */
+ const TYPE_LONGBLOB = 13;
+
+ /**
+ * Big integer abstract type
+ */
+ const TYPE_BIGINTEGER = 14;
+
+ /**
+ * Json abstract type
+ */
+ const TYPE_JSON = 15;
+
+ /**
+ * Jsonb abstract type
+ */
+ const TYPE_JSONB = 16;
+
+ /**
+ * Bind Type Null
+ */
+ const BIND_PARAM_NULL = 0;
+
+ /**
+ * Bind Type Integer
+ */
+ const BIND_PARAM_INT = 1;
+
+ /**
+ * Bind Type String
+ */
+ const BIND_PARAM_STR = 2;
+
+ /**
+ * Bind Type Blob
+ */
+ const BIND_PARAM_BLOB = 3;
+
+ /**
+ * Bind Type Bool
+ */
+ const BIND_PARAM_BOOL = 5;
+
+ /**
+ * Bind Type Decimal
+ */
+ const BIND_PARAM_DECIMAL = 32;
+
+ /**
+ * Skip binding by type
+ */
+ const BIND_SKIP = 1024;
+
+ /**
+ * Column's name
+ *
+ * @var string
+ */
+ protected $_name;
+
+ /**
+ * Schema which table related is
+ *
+ * @var string
+ */
+ protected $_schemaName;
+
+ /**
+ * Column data type
+ *
+ * @var int|string
+ */
+ protected $_type;
+
+ /**
+ * Column data type reference
+ *
+ * @var int
+ */
+ protected $_typeReference;
+
+ /**
+ * Column data type values
+ *
+ * @var array|string
+ */
+ protected $_typeValues;
+
+ /**
+ * The column have some numeric type?
+ */
+ protected $_isNumeric = false;
+
+ /**
+ * Integer column size
+ *
+ * @var int
+ */
+ protected $_size = 0;
+
+ /**
+ * Integer column number scale
+ *
+ * @var int
+ */
+ protected $_scale = 0;
+
+ /**
+ * Default column value
+ */
+ protected $_default = null;
+
+ /**
+ * Integer column unsigned?
+ *
+ * @var boolean
+ */
+ protected $_unsigned = false;
+
+ /**
+ * Column not nullable?
+ *
+ * @var boolean
+ */
+ protected $_notNull = false;
+
+ /**
+ * Column is part of the primary key?
+ */
+ protected $_primary = false;
+
+ /**
+ * Column is autoIncrement?
+ *
+ * @var boolean
+ */
+ protected $_autoIncrement = false;
+
+ /**
+ * Position is first
+ *
+ * @var boolean
+ */
+ protected $_first = false;
+
+ /**
+ * Column Position
+ *
+ * @var string
+ */
+ protected $_after;
+
+ /**
+ * Bind Type
+ */
+ protected $_bindType = 2;
+
+
+ /**
+ * Column's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Schema which table related is
+ *
+ * @return string
+ */
+ public function getSchemaName() {}
+
+ /**
+ * Column data type
+ *
+ * @return int|string
+ */
+ public function getType() {}
+
+ /**
+ * Column data type reference
+ *
+ * @return int
+ */
+ public function getTypeReference() {}
+
+ /**
+ * Column data type values
+ *
+ * @return array|string
+ */
+ public function getTypeValues() {}
+
+ /**
+ * Integer column size
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Integer column number scale
+ *
+ * @return int
+ */
+ public function getScale() {}
+
+ /**
+ * Default column value
+ */
+ public function getDefault() {}
+
+ /**
+ * Phalcon\Db\Column constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Returns true if number column is unsigned
+ *
+ * @return bool
+ */
+ public function isUnsigned() {}
+
+ /**
+ * Not null
+ *
+ * @return bool
+ */
+ public function isNotNull() {}
+
+ /**
+ * Column is part of the primary key?
+ *
+ * @return bool
+ */
+ public function isPrimary() {}
+
+ /**
+ * Auto-Increment
+ *
+ * @return bool
+ */
+ public function isAutoIncrement() {}
+
+ /**
+ * Check whether column have an numeric type
+ *
+ * @return bool
+ */
+ public function isNumeric() {}
+
+ /**
+ * Check whether column have first position in table
+ *
+ * @return bool
+ */
+ public function isFirst() {}
+
+ /**
+ * Check whether field absolute to position in table
+ *
+ * @return string
+ */
+ public function getAfterPosition() {}
+
+ /**
+ * Returns the type of bind handling
+ *
+ * @return int
+ */
+ public function getBindType() {}
+
+ /**
+ * Restores the internal state of a Phalcon\Db\Column object
+ *
+ * @param array $data
+ * @return Column
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/ColumnInterface.php b/ide/2.0.5/Phalcon/db/ColumnInterface.php
new file mode 100644
index 000000000..658903aaf
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/ColumnInterface.php
@@ -0,0 +1,140 @@
+
+ * $sql = $dialect->limit('SELECTFROM robots', 10);
+ * echo $sql; // SELECTFROM robots LIMIT 10
+ * $sql = $dialect->limit('SELECTFROM robots', [10, 50]);
+ * echo $sql; // SELECTFROM robots LIMIT 10 OFFSET 50
+ *
+ *
+ * @param string $sqlQuery
+ * @param mixed $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * $sql = $dialect->forUpdate('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots FOR UPDATE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * $sql = $dialect->sharedLock('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots LOCK IN SHARE MODE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Gets a list of columns with escaped identifiers
+ *
+ * echo $dialect->getColumnList(array('column1', 'column'));
+ *
+ *
+ * @param array $columnList
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ public final function getColumnList($columnList, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param mixed $column
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ public final function getSqlColumn($column, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Transforms an intermediate representation for a expression into a database system valid expression
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ public function getSqlExpression($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Transform an intermediate representation of a schema/table into a database system valid expression
+ *
+ * @param mixed $table
+ * @param string $escapeChar
+ * @return string
+ */
+ public final function getSqlTable($table, $escapeChar = null) {}
+
+ /**
+ * Builds a SELECT statement
+ *
+ * @param array $definition
+ * @return string
+ */
+ public function select($definition) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+ /**
+ * Generate SQL to create a new savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Generate SQL to release a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Generate SQL to rollback a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionScalar($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve object expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionObject($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve qualified expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionQualified($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve binary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionBinaryOperations($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve unary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionUnaryOperations($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve function calls
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionFunctionCall($expression, $escapeChar = null, $bindCounts) {}
+
+ /**
+ * Resolve Lists
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionList($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionAll($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CAST of values
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionCastValue($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve CONVERT of values encodings
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionConvertValue($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve CASE expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionCase($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a FROM clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionFrom($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a JOINs clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionJoins($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a WHERE clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionWhere($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a GROUP BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionGroupBy($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a HAVING clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionHaving($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a ORDER BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionOrderBy($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a LIMIT clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionLimit($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Prepares column for this RDBMS
+ *
+ * @param string $qualified
+ * @param string $alias
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareColumnAlias($qualified, $alias = null, $escapeChar = null) {}
+
+ /**
+ * Prepares table for this RDBMS
+ *
+ * @param string $table
+ * @param string $schema
+ * @param string $alias
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareTable($table, $schema = null, $alias = null, $escapeChar = null) {}
+
+ /**
+ * Prepares qualified for this RDBMS
+ *
+ * @param string $column
+ * @param string $domain
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareQualified($column, $domain = null, $escapeChar = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/DialectInterface.php b/ide/2.0.5/Phalcon/db/DialectInterface.php
new file mode 100644
index 000000000..a1deb6019
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/DialectInterface.php
@@ -0,0 +1,290 @@
+
+ * $profiler = new \Phalcon\Db\Profiler();
+ * //Set the connection profiler
+ * $connection->setProfiler($profiler);
+ * $sql = "SELECT buyer_name, quantity, product_name
+ * FROM buyers LEFT JOIN products ON
+ * buyers.pid=products.id";
+ * //Execute a SQL statement
+ * $connection->query($sql);
+ * //Get the last profile in the profiler
+ * $profile = $profiler->getLastProfile();
+ * echo "SQL Statement: ", $profile->getSQLStatement(), "\n";
+ * echo "Start Time: ", $profile->getInitialTime(), "\n";
+ * echo "Final Time: ", $profile->getFinalTime(), "\n";
+ * echo "Total Elapsed Time: ", $profile->getTotalElapsedSeconds(), "\n";
+ *
+ */
+class Profiler
+{
+ /**
+ * All the Phalcon\Db\Profiler\Item in the active profile
+ *
+ * @var array
+ */
+ protected $_allProfiles;
+
+ /**
+ * Active Phalcon\Db\Profiler\Item
+ *
+ * @var Phalcon\Db\Profiler\Item
+ */
+ protected $_activeProfile;
+
+ /**
+ * Total time spent by all profiles to complete
+ *
+ * @var float
+ */
+ protected $_totalSeconds = 0;
+
+
+ /**
+ * Starts the profile of a SQL sentence
+ *
+ * @param string $sqlStatement
+ * @param mixed $sqlVariables
+ * @param mixed $sqlBindTypes
+ * @return \Phalcon\Db\Profiler
+ */
+ public function startProfile($sqlStatement, $sqlVariables = null, $sqlBindTypes = null) {}
+
+ /**
+ * Stops the active profile
+ *
+ * @return Profiler
+ */
+ public function stopProfile() {}
+
+ /**
+ * Returns the total number of SQL statements processed
+ *
+ * @return int
+ */
+ public function getNumberTotalStatements() {}
+
+ /**
+ * Returns the total time in seconds spent by the profiles
+ *
+ * @return double
+ */
+ public function getTotalElapsedSeconds() {}
+
+ /**
+ * Returns all the processed profiles
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getProfiles() {}
+
+ /**
+ * Resets the profiler, cleaning up all the profiles
+ *
+ * @return Profiler
+ */
+ public function reset() {}
+
+ /**
+ * Returns the last profile executed in the profiler
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getLastProfile() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/RawValue.php b/ide/2.0.5/Phalcon/db/RawValue.php
new file mode 100644
index 000000000..fe66e8fd4
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/RawValue.php
@@ -0,0 +1,45 @@
+
+ * $subscriber = new Subscribers();
+ * $subscriber->email = 'andres@phalconphp.com';
+ * $subscriber->createdAt = new \Phalcon\Db\RawValue('now()');
+ * $subscriber->save();
+ *
+ */
+class RawValue
+{
+ /**
+ * Raw value without quoting or formating
+ *
+ * @var string
+ */
+ protected $_value;
+
+
+ /**
+ * Raw value without quoting or formating
+ *
+ * @return string
+ */
+ public function getValue() {}
+
+ /**
+ * Raw value without quoting or formating
+ */
+ public function __toString() {}
+
+ /**
+ * Phalcon\Db\RawValue constructor
+ *
+ * @param mixed $value
+ */
+ public function __construct($value) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/Reference.php b/ide/2.0.5/Phalcon/db/Reference.php
new file mode 100644
index 000000000..ad0ca1f80
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/Reference.php
@@ -0,0 +1,132 @@
+
+ * $reference = new \Phalcon\Db\Reference("field_fk", array(
+ * 'referencedSchema' => "invoicing",
+ * 'referencedTable' => "products",
+ * 'columns' => array("product_type", "product_code"),
+ * 'referencedColumns' => array("type", "code")
+ * ));
+ *
+ */
+class Reference implements \Phalcon\Db\ReferenceInterface
+{
+ /**
+ * Constraint name
+ *
+ * @var string
+ */
+ protected $_name;
+
+
+ protected $_schemaName;
+
+
+ protected $_referencedSchema;
+
+ /**
+ * Referenced Table
+ *
+ * @var string
+ */
+ protected $_referencedTable;
+
+ /**
+ * Local reference columns
+ *
+ * @var array
+ */
+ protected $_columns;
+
+ /**
+ * Referenced Columns
+ *
+ * @var array
+ */
+ protected $_referencedColumns;
+
+ /**
+ * ON DELETE
+ *
+ * @var array
+ */
+ protected $_onDelete;
+
+ /**
+ * ON UPDATE
+ *
+ * @var array
+ */
+ protected $_onUpdate;
+
+
+ /**
+ * Constraint name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+
+ public function getSchemaName() {}
+
+
+ public function getReferencedSchema() {}
+
+ /**
+ * Referenced Table
+ *
+ * @return string
+ */
+ public function getReferencedTable() {}
+
+ /**
+ * Local reference columns
+ *
+ * @return array
+ */
+ public function getColumns() {}
+
+ /**
+ * Referenced Columns
+ *
+ * @return array
+ */
+ public function getReferencedColumns() {}
+
+ /**
+ * ON DELETE
+ *
+ * @return array
+ */
+ public function getOnDelete() {}
+
+ /**
+ * ON UPDATE
+ *
+ * @return array
+ */
+ public function getOnUpdate() {}
+
+ /**
+ * Phalcon\Db\Reference constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Restore a Phalcon\Db\Reference object from export
+ *
+ * @param array $data
+ * @return Reference
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/ReferenceInterface.php b/ide/2.0.5/Phalcon/db/ReferenceInterface.php
new file mode 100644
index 000000000..89e52781f
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/ReferenceInterface.php
@@ -0,0 +1,84 @@
+
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306'
+ * ));
+ *
+ */
+abstract class Pdo extends \Phalcon\Db\Adapter
+{
+ /**
+ * PDO Handler
+ */
+ protected $_pdo;
+
+ /**
+ * Last affected rows
+ */
+ protected $_affectedRows;
+
+
+ /**
+ * Constructor for Phalcon\Db\Adapter\Pdo
+ *
+ * @param array $descriptor
+ */
+ public function __construct($descriptor) {}
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection
+ *
+ * //Make a connection
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * ));
+ * //Reconnect
+ * $connection->connect();
+ *
+ *
+ * @param mixed $descriptor
+ * @param $array descriptor
+ * @return
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns a PDO prepared statement to be executed with 'executePrepared'
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param string $sqlStatement
+ * @return \PDOStatement
+ */
+ public function prepare($sqlStatement) {}
+
+ /**
+ * Executes a prepared statement binding. This function uses integer indexes starting from zero
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param \PDOStatement $statement
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return \PDOStatement
+ */
+ public function executePrepared(\PDOStatement $statement, $placeholders, $dataTypes) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server is returning rows
+ *
+ * //Querying data
+ * $resultset = $connection->query("SELECTFROM robots WHERE type='mechanical'");
+ * $resultset = $connection->query("SELECTFROM robots WHERE type=?", array("mechanical"));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool|\Phalcon\Db\ResultInterface
+ */
+ public function query($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server doesn't return any rows
+ *
+ * //Inserting data
+ * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
+ * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool
+ */
+ public function execute($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Returns the number of affected rows by the lastest INSERT/UPDATE/DELETE executed in the database system
+ *
+ * $connection->execute("DELETE FROM robots");
+ * echo $connection->affectedRows(), ' were deleted';
+ *
+ *
+ * @return int
+ */
+ public function affectedRows() {}
+
+ /**
+ * Closes the active connection returning success. Phalcon automatically closes and destroys
+ * active connections when the request ends
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * $escapedTable = $connection->escapeIdentifier('robots');
+ * $escapedTable = $connection->escapeIdentifier(array('store', 'robots'));
+ *
+ *
+ * @param string $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Escapes a value to avoid SQL injections according to the active charset in the connection
+ *
+ * $escapedStr = $connection->escapeString('some dangerous value');
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public function escapeString($str) {}
+
+ /**
+ * Converts bound parameters such as :name: or ?1 into PDO bind params ?
+ *
+ * print_r($connection->convertBoundParams('SELECTFROM robots WHERE name = :name:', array('Bender')));
+ *
+ *
+ * @param string $sql
+ * @param array $params
+ * @return array
+ */
+ public function convertBoundParams($sql, $params = array()) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int|boolean
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Starts a transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function begin($nesting = true) {}
+
+ /**
+ * Rollbacks the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function rollback($nesting = true) {}
+
+ /**
+ * Commits the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function commit($nesting = true) {}
+
+ /**
+ * Returns the current transaction nesting level
+ *
+ * @return int
+ */
+ public function getTransactionLevel() {}
+
+ /**
+ * Checks whether the connection is under a transaction
+ *
+ * $connection->begin();
+ * var_dump($connection->isUnderTransaction()); //true
+ *
+ *
+ * @return bool
+ */
+ public function isUnderTransaction() {}
+
+ /**
+ * Return internal PDO handler
+ *
+ * @return \Pdo
+ */
+ public function getInternalHandler() {}
+
+ /**
+ * Return the error info, if any
+ *
+ * @return array
+ */
+ public function getErrorInfo() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/adapter/pdo/Mysql.php b/ide/2.0.5/Phalcon/db/adapter/pdo/Mysql.php
new file mode 100644
index 000000000..dec124c0e
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/adapter/pdo/Mysql.php
@@ -0,0 +1,48 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "port" => 3306,
+ * "username" => "sigma",
+ * "password" => "secret"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql($config);
+ *
+ */
+class Mysql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "mysql";
+
+
+ protected $_dialectType = "mysql";
+
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * @param string|array $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/adapter/pdo/Oracle.php b/ide/2.0.5/Phalcon/db/adapter/pdo/Oracle.php
new file mode 100644
index 000000000..9e45aea25
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/adapter/pdo/Oracle.php
@@ -0,0 +1,84 @@
+
+ * $config = array(
+ * "dbname" => "//localhost/dbname",
+ * "username" => "oracle",
+ * "password" => "oracle"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Oracle($config);
+ *
+ */
+class Oracle extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "oci";
+
+
+ protected $_dialectType = "oracle";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param array $descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ * print_r($connection->describeColumns("posts")); ?>
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return the default identity value to insert in an identity column
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/adapter/pdo/Postgresql.php b/ide/2.0.5/Phalcon/db/adapter/pdo/Postgresql.php
new file mode 100644
index 000000000..301ae233c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/adapter/pdo/Postgresql.php
@@ -0,0 +1,99 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "username" => "postgres",
+ * "password" => ""
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Postgresql($config);
+ *
+ */
+class Postgresql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "pgsql";
+
+
+ protected $_dialectType = "postgresql";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/adapter/pdo/Sqlite.php b/ide/2.0.5/Phalcon/db/adapter/pdo/Sqlite.php
new file mode 100644
index 000000000..2a89f63eb
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/adapter/pdo/Sqlite.php
@@ -0,0 +1,92 @@
+
+ * $config = array(
+ * "dbname" => "/tmp/test.sqlite"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Sqlite($config);
+ *
+ */
+class Sqlite extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "sqlite";
+
+
+ protected $_dialectType = "sqlite";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\IndexInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\IndexInterface
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\ReferenceInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\ReferenceInterface
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Returns the default value to make the RBDM use the default value declared in the table definition
+ *
+ * //Inserting a new robot with a valid default value for the column 'year'
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", $connection->getDefaultValue()),
+ * array("name", "year")
+ * );
+ *
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultValue() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/dialect/MySQL.php b/ide/2.0.5/Phalcon/db/dialect/MySQL.php
new file mode 100644
index 000000000..6e8af8d16
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/dialect/MySQL.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Generates SQL to add the table creation options
+ *
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/dialect/Oracle.php b/ide/2.0.5/Phalcon/db/dialect/Oracle.php
new file mode 100644
index 000000000..972fdf46e
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/dialect/Oracle.php
@@ -0,0 +1,257 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/dialect/Postgresql.php b/ide/2.0.5/Phalcon/db/dialect/Postgresql.php
new file mode 100644
index 000000000..0a3b9f37e
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/dialect/Postgresql.php
@@ -0,0 +1,239 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/dialect/Sqlite.php b/ide/2.0.5/Phalcon/db/dialect/Sqlite.php
new file mode 100644
index 000000000..c606ad0c5
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/dialect/Sqlite.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query indexes detail on a table
+ *
+ * @param string $index
+ * @return string
+ */
+ public function describeIndex($index) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/db/profiler/Item.php b/ide/2.0.5/Phalcon/db/profiler/Item.php
new file mode 100644
index 000000000..79ad83855
--- /dev/null
+++ b/ide/2.0.5/Phalcon/db/profiler/Item.php
@@ -0,0 +1,124 @@
+
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ */
+class Pdo implements \Phalcon\Db\ResultInterface
+{
+
+ protected $_connection;
+
+
+ protected $_result;
+
+ /**
+ * Active fetch mode
+ */
+ protected $_fetchMode = Db::FETCH_OBJ;
+
+ /**
+ * Internal resultset
+ *
+ * @var \PDOStatement
+ */
+ protected $_pdoStatement;
+
+
+ protected $_sqlStatement;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_rowCount = false;
+
+
+ /**
+ * Phalcon\Db\Result\Pdo constructor
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \PDOStatement $result
+ * @param string $sqlStatement
+ * @param array $bindParams
+ * @param array $bindTypes
+ */
+ public function __construct(Db\AdapterInterface $connection, \PDOStatement $result, $sqlStatement = null, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Allows to execute the statement again. Some database systems don't support scrollable cursors,
+ * So, as cursors are forward only, we need to execute the cursor again to fetch rows from the begining
+ *
+ * @return bool
+ */
+ public function execute() {}
+
+ /**
+ * Fetches an array/object of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ * while ($robot = $result->fetch()) {
+ * echo $robot->name;
+ * }
+ *
+ *
+ * @param mixed $fetchStyle
+ * @param mixed $cursorOrientation
+ * @param mixed $cursorOffset
+ */
+ public function fetch($fetchStyle = null, $cursorOrientation = null, $cursorOffset = null) {}
+
+ /**
+ * Returns an array of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ */
+ public function fetchArray() {}
+
+ /**
+ * Returns an array of arrays containing all the records in the result
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $robots = $result->fetchAll();
+ *
+ *
+ * @param mixed $fetchStyle
+ * @param mixed $fetchArgument
+ * @param mixed $ctorArgs
+ * @return array
+ */
+ public function fetchAll($fetchStyle = null, $fetchArgument = null, $ctorArgs = null) {}
+
+ /**
+ * Gets number of rows returned by a resultset
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * echo 'There are ', $result->numRows(), ' rows in the resultset';
+ *
+ *
+ * @return int
+ */
+ public function numRows() {}
+
+ /**
+ * Moves internal resultset cursor to another position letting us to fetch a certain row
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->dataSeek(2); // Move to third row on result
+ * $row = $result->fetch(); // Fetch third row
+ *
+ *
+ * @param long $number
+ */
+ public function dataSeek($number) {}
+
+ /**
+ * Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch()
+ *
+ * //Return array with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * //Return associative array without integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_ASSOC);
+ * //Return associative array together with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_BOTH);
+ * //Return an object
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ *
+ *
+ * @param int $fetchMode
+ * @param mixed $colNoOrClassNameOrObject
+ * @param mixed $ctorargs
+ * @return bool
+ */
+ public function setFetchMode($fetchMode, $colNoOrClassNameOrObject = null, $ctorargs = null) {}
+
+ /**
+ * Gets the internal PDO result object
+ *
+ * @return \PDOStatement
+ */
+ public function getInternalResult() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/debug/Dump.php b/ide/2.0.5/Phalcon/debug/Dump.php
new file mode 100644
index 000000000..6d610b011
--- /dev/null
+++ b/ide/2.0.5/Phalcon/debug/Dump.php
@@ -0,0 +1,134 @@
+
+ * $foo = 123;
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ */
+class Dump
+{
+
+ protected $_detailed = false;
+
+
+ protected $_methods = null;
+
+
+ protected $_styles;
+
+
+
+ public function getDetailed() {}
+
+ /**
+ * @param mixed $detailed
+ */
+ public function setDetailed($detailed) {}
+
+ /**
+ * Phalcon\Debug\Dump constructor
+ *
+ * @param array $styles
+ * @param boolean $detailed debug object's private and protected properties
+ */
+ public function __construct($styles = null, $detailed = false) {}
+
+ /**
+ * Alias of variables() method
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function all() {}
+
+ /**
+ * Get style for type
+ *
+ * @param string $type
+ * @return string
+ */
+ protected function getStyle($type) {}
+
+ /**
+ * Set styles for vars type
+ *
+ * @param mixed $styles
+ * @return array
+ */
+ public function setStyles($styles = null) {}
+
+ /**
+ * Alias of variable() method
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function one($variable, $name = null) {}
+
+ /**
+ * Prepare an HTML string of information about a single variable.
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @param int $tab
+ * @return string
+ */
+ protected function output($variable, $name = null, $tab = 1) {}
+
+ /**
+ * Returns an HTML string of information about a single variable.
+ *
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function variable($variable, $name = null) {}
+
+ /**
+ * Returns an HTML string of debugging information about any number of
+ * variables, each wrapped in a "pre" tag.
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function variables() {}
+
+ /**
+ * Returns an JSON string of information about a single variable.
+ *
+ * $foo = ["key" => "value"];
+ * echo (new \Phalcon\Debug\Dump())->toJson($foo);
+ * $foo = new stdClass();
+ * $foo->bar = 'buz';
+ * echo (new \Phalcon\Debug\Dump())->toJson($foo);
+ *
+ *
+ * @param mixed $variable
+ * @return string
+ */
+ public function toJson($variable) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/debug/Exception.php b/ide/2.0.5/Phalcon/debug/Exception.php
new file mode 100644
index 000000000..12c2c2b76
--- /dev/null
+++ b/ide/2.0.5/Phalcon/debug/Exception.php
@@ -0,0 +1,12 @@
+
+ * $service = new \Phalcon\Di\Service('request', 'Phalcon\Http\Request');
+ * $request = service->resolve();
+ *
+ */
+class Service implements \Phalcon\Di\ServiceInterface
+{
+
+ protected $_name;
+
+
+ protected $_definition;
+
+
+ protected $_shared = false;
+
+
+ protected $_resolved = false;
+
+
+ protected $_sharedInstance;
+
+
+ /**
+ * Phalcon\Di\Service
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param boolean $shared
+ */
+ public final function __construct($name, $definition, $shared = false) {}
+
+ /**
+ * Returns the service's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets if the service is shared or not
+ *
+ * @param bool $shared
+ */
+ public function setShared($shared) {}
+
+ /**
+ * Check whether the service is shared or not
+ *
+ * @return bool
+ */
+ public function isShared() {}
+
+ /**
+ * Sets/Resets the shared instance related to the service
+ *
+ * @param mixed $sharedInstance
+ */
+ public function setSharedInstance($sharedInstance) {}
+
+ /**
+ * Set the service definition
+ *
+ * @param mixed $definition
+ */
+ public function setDefinition($definition) {}
+
+ /**
+ * Returns the service definition
+ *
+ * @return mixed
+ */
+ public function getDefinition() {}
+
+ /**
+ * Resolves the service
+ *
+ * @param array $parameters
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @return mixed
+ */
+ public function resolve($parameters = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Changes a parameter in the definition without resolve the service
+ *
+ * @param int $position
+ * @param array $parameter
+ * @return Service
+ */
+ public function setParameter($position, $parameter) {}
+
+ /**
+ * Returns a parameter in a specific position
+ *
+ * @param int $position
+ * @return array
+ */
+ public function getParameter($position) {}
+
+ /**
+ * Returns true if the service was resolved
+ *
+ * @return bool
+ */
+ public function isResolved() {}
+
+ /**
+ * Restore the internal state of a service
+ *
+ * @param array $attributes
+ * @return Service
+ */
+ public static function __set_state($attributes) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/di/ServiceInterface.php b/ide/2.0.5/Phalcon/di/ServiceInterface.php
new file mode 100644
index 000000000..97df909cf
--- /dev/null
+++ b/ide/2.0.5/Phalcon/di/ServiceInterface.php
@@ -0,0 +1,73 @@
+
+ * $eventsManager->fire('db', $connection);
+ *
+ *
+ * @param string $eventType
+ * @param object $source
+ * @param mixed $data
+ * @param boolean $cancelable
+ * @return mixed
+ */
+ public function fire($eventType, $source, $data = null, $cancelable = true) {}
+
+ /**
+ * Check whether certain type of event has listeners
+ *
+ * @param string $type
+ * @return bool
+ */
+ public function hasListeners($type) {}
+
+ /**
+ * Returns all the attached listeners of a certain type
+ *
+ * @param string $type
+ * @return array
+ */
+ public function getListeners($type) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/events/ManagerInterface.php b/ide/2.0.5/Phalcon/events/ManagerInterface.php
new file mode 100644
index 000000000..394032467
--- /dev/null
+++ b/ide/2.0.5/Phalcon/events/ManagerInterface.php
@@ -0,0 +1,55 @@
+
+ * $request = new \Phalcon\Http\Request();
+ * if ($request->isPost() == true) {
+ * if ($request->isAjax() == true) {
+ * echo 'Request was made using POST and AJAX';
+ * }
+ * }
+ *
+ */
+class Request implements \Phalcon\Http\RequestInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_rawBody;
+
+
+ protected $_filter;
+
+
+ protected $_putCache;
+
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Gets a variable from the $_REQUEST superglobal applying filters if needed.
+ * If no parameters are given the $_REQUEST superglobal is returned
+ *
+ * //Returns value from $_REQUEST["user_email"] without sanitizing
+ * $userEmail = $request->get("user_email");
+ * //Returns value from $_REQUEST["user_email"] with sanitizing
+ * $userEmail = $request->get("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function get($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from the $_POST superglobal applying filters if needed
+ * If no parameters are given the $_POST superglobal is returned
+ *
+ * //Returns value from $_POST["user_email"] without sanitizing
+ * $userEmail = $request->getPost("user_email");
+ * //Returns value from $_POST["user_email"] with sanitizing
+ * $userEmail = $request->getPost("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPost($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from put request
+ *
+ * //Returns value from $_PUT["user_email"] without sanitizing
+ * $userEmail = $request->getPut("user_email");
+ * //Returns value from $_PUT["user_email"] with sanitizing
+ * $userEmail = $request->getPut("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPut($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_GET superglobal applying filters if needed
+ * If no parameters are given the $_GET superglobal is returned
+ *
+ * //Returns value from $_GET["id"] without sanitizing
+ * $id = $request->getQuery("id");
+ * //Returns value from $_GET["id"] with sanitizing
+ * $id = $request->getQuery("id", "int");
+ * //Returns value from $_GET["id"] with a default value
+ * $id = $request->getQuery("id", null, 150);
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getQuery($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Helper to get data from superglobals, applying filters if needed.
+ * If no parameters are given the superglobal is returned.
+ *
+ * @param array $source
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ protected final function getHelper($source, $name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_SERVER superglobal
+ *
+ * @param string $name
+ */
+ public function getServer($name) {}
+
+ /**
+ * Checks whether $_REQUEST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Checks whether $_POST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPost($name) {}
+
+ /**
+ * Checks whether the PUT data has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPut($name) {}
+
+ /**
+ * Checks whether $_GET superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasQuery($name) {}
+
+ /**
+ * Checks whether $_SERVER superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public final function hasServer($name) {}
+
+ /**
+ * Gets HTTP header from request data
+ *
+ * @param string $header
+ * @return string
+ */
+ public final function getHeader($header) {}
+
+ /**
+ * Gets HTTP schema (http/https)
+ *
+ * @return string
+ */
+ public function getScheme() {}
+
+ /**
+ * Checks whether request has been made using ajax
+ *
+ * @return bool
+ */
+ public function isAjax() {}
+
+ /**
+ * Checks whether request has been made using SOAP
+ *
+ * @return bool
+ */
+ public function isSoapRequested() {}
+
+ /**
+ * Checks whether request has been made using any secure layer
+ *
+ * @return bool
+ */
+ public function isSecureRequest() {}
+
+ /**
+ * Gets HTTP raw request body
+ *
+ * @return string
+ */
+ public function getRawBody() {}
+
+ /**
+ * Gets decoded JSON HTTP raw request body
+ *
+ * @param bool $associative
+ * @return array|bool|\stdClass
+ */
+ public function getJsonRawBody($associative = false) {}
+
+ /**
+ * Gets active server address IP
+ *
+ * @return string
+ */
+ public function getServerAddress() {}
+
+ /**
+ * Gets active server name
+ *
+ * @return string
+ */
+ public function getServerName() {}
+
+ /**
+ * Gets information about schema, host and port used by the request
+ *
+ * @return string
+ */
+ public function getHttpHost() {}
+
+ /**
+ * Gets HTTP URI which request has been made
+ *
+ * @return string
+ */
+ public final function getURI() {}
+
+ /**
+ * Gets most possible client IPv4 Address. This method search in _SERVER['REMOTE_ADDR'] and optionally in _SERVER['HTTP_X_FORWARDED_FOR']
+ *
+ * @param bool $trustForwardedHeader
+ * @return string|bool
+ */
+ public function getClientAddress($trustForwardedHeader = false) {}
+
+ /**
+ * Gets HTTP method which request has been made
+ *
+ * @return string
+ */
+ public final function getMethod() {}
+
+ /**
+ * Gets HTTP user agent used to made the request
+ *
+ * @return string
+ */
+ public function getUserAgent() {}
+
+ /**
+ * Checks if a method is a valid HTTP method
+ *
+ * @param string $method
+ * @return bool
+ */
+ public function isValidHttpMethod($method) {}
+
+ /**
+ * Check if HTTP method match any of the passed methods
+ * When strict is true it checks if validated methods are real HTTP methods
+ *
+ * @param mixed $methods
+ * @param bool $strict
+ * @return bool
+ */
+ public function isMethod($methods, $strict = false) {}
+
+ /**
+ * Checks whether HTTP method is POST. if _SERVER["REQUEST_METHOD"]==="POST"
+ *
+ * @return bool
+ */
+ public function isPost() {}
+
+ /**
+ * Checks whether HTTP method is GET. if _SERVER["REQUEST_METHOD"]==="GET"
+ *
+ * @return bool
+ */
+ public function isGet() {}
+
+ /**
+ * Checks whether HTTP method is PUT. if _SERVER["REQUEST_METHOD"]==="PUT"
+ *
+ * @return bool
+ */
+ public function isPut() {}
+
+ /**
+ * Checks whether HTTP method is PATCH. if _SERVER["REQUEST_METHOD"]==="PATCH"
+ *
+ * @return bool
+ */
+ public function isPatch() {}
+
+ /**
+ * Checks whether HTTP method is HEAD. if _SERVER["REQUEST_METHOD"]==="HEAD"
+ *
+ * @return bool
+ */
+ public function isHead() {}
+
+ /**
+ * Checks whether HTTP method is DELETE. if _SERVER["REQUEST_METHOD"]==="DELETE"
+ *
+ * @return bool
+ */
+ public function isDelete() {}
+
+ /**
+ * Checks whether HTTP method is OPTIONS. if _SERVER["REQUEST_METHOD"]==="OPTIONS"
+ *
+ * @return bool
+ */
+ public function isOptions() {}
+
+ /**
+ * Checks whether request include attached files
+ *
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ public function hasFiles($onlySuccessful = false) {}
+
+ /**
+ * Recursively counts file in an array of files
+ *
+ * @param mixed $data
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ protected final function hasFileHelper($data, $onlySuccessful) {}
+
+ /**
+ * Gets attached files as Phalcon\Http\Request\File instances
+ *
+ * @param bool $onlySuccessful
+ * @return \Phalcon\Http\Request\File
+ */
+ public function getUploadedFiles($onlySuccessful = false) {}
+
+ /**
+ * Smooth out $_FILES to have plain array with all files uploaded
+ *
+ * @param array $names
+ * @param array $types
+ * @param array $tmp_names
+ * @param array $sizes
+ * @param array $errors
+ * @param string $prefix
+ * @return array
+ */
+ protected final function smoothFiles($names, $types, $tmp_names, $sizes, $errors, $prefix) {}
+
+ /**
+ * Returns the available headers in the request
+ *
+ * @return array
+ */
+ public function getHeaders() {}
+
+ /**
+ * Gets web page that refers active request. ie: http://www.google.com
+ *
+ * @return string
+ */
+ public function getHTTPReferer() {}
+
+ /**
+ * Process a request header and return an array of values with their qualities
+ *
+ * @param string $serverIndex
+ * @param string $name
+ * @return array
+ */
+ protected final function _getQualityHeader($serverIndex, $name) {}
+
+ /**
+ * Process a request header and return the one with best quality
+ *
+ * @param array $qualityParts
+ * @param string $name
+ * @return string
+ */
+ protected final function _getBestQuality($qualityParts, $name) {}
+
+ /**
+ * Gets content type which request has been made
+ *
+ * @return string|null
+ */
+ public function getContentType() {}
+
+ /**
+ * Gets an array with mime/types and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return array
+ */
+ public function getAcceptableContent() {}
+
+ /**
+ * Gets best mime/type accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return string
+ */
+ public function getBestAccept() {}
+
+ /**
+ * Gets a charsets array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return variable
+ */
+ public function getClientCharsets() {}
+
+ /**
+ * Gets best charset accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return string
+ */
+ public function getBestCharset() {}
+
+ /**
+ * Gets languages array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return array
+ */
+ public function getLanguages() {}
+
+ /**
+ * Gets best language accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return string
+ */
+ public function getBestLanguage() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_USER']
+ *
+ * @return array|null
+ */
+ public function getBasicAuth() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_DIGEST']
+ *
+ * @return array
+ */
+ public function getDigestAuth() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/http/RequestInterface.php b/ide/2.0.5/Phalcon/http/RequestInterface.php
new file mode 100644
index 000000000..c1888e6b9
--- /dev/null
+++ b/ide/2.0.5/Phalcon/http/RequestInterface.php
@@ -0,0 +1,306 @@
+
+ * $response = new \Phalcon\Http\Response();
+ * $response->setStatusCode(200, "OK");
+ * $response->setContent("Hello");
+ * $response->send();
+ *
+ */
+class Response implements \Phalcon\Http\ResponseInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_sent = false;
+
+
+ protected $_content;
+
+
+ protected $_headers;
+
+
+ protected $_cookies;
+
+
+ protected $_file;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_statusCodes;
+
+
+ /**
+ * Phalcon\Http\Response constructor
+ *
+ * @param string $content
+ * @param int $code
+ * @param string $status
+ */
+ public function __construct($content = null, $code = null, $status = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the HTTP response code
+ *
+ * $response->setStatusCode(404, "Not Found");
+ *
+ *
+ * @param int $code
+ * @param string $message
+ * @return Response
+ */
+ public function setStatusCode($code, $message = null) {}
+
+ /**
+ * Returns the status code
+ *
+ * print_r($response->getStatusCode());
+ *
+ *
+ * @return array
+ */
+ public function getStatusCode() {}
+
+ /**
+ * Sets a headers bag for the response externally
+ *
+ * @param mixed $headers
+ * @return Response
+ */
+ public function setHeaders(\Phalcon\Http\Response\HeadersInterface $headers) {}
+
+ /**
+ * Returns headers set by the user
+ *
+ * @return \Phalcon\Http\Response\HeadersInterface
+ */
+ public function getHeaders() {}
+
+ /**
+ * Sets a cookies bag for the response externally
+ *
+ * @param mixed $cookies
+ * @return Response
+ */
+ public function setCookies(\Phalcon\Http\Response\CookiesInterface $cookies) {}
+
+ /**
+ * Returns coookies set by the user
+ *
+ * @return \Phalcon\Http\Response\CookiesInterface
+ */
+ public function getCookies() {}
+
+ /**
+ * Overwrites a header in the response
+ *
+ * $response->setHeader("Content-Type", "text/plain");
+ *
+ *
+ * @param string $name
+ * @param string $value
+ * @return \Phalcon\Http\Response
+ */
+ public function setHeader($name, $value) {}
+
+ /**
+ * Send a raw header to the response
+ *
+ * $response->setRawHeader("HTTP/1.1 404 Not Found");
+ *
+ *
+ * @param string $header
+ * @return Response
+ */
+ public function setRawHeader($header) {}
+
+ /**
+ * Resets all the stablished headers
+ *
+ * @return Response
+ */
+ public function resetHeaders() {}
+
+ /**
+ * Sets a Expires header to use HTTP cache
+ *
+ * $this->response->setExpires(new DateTime());
+ *
+ *
+ * @param mixed $datetime
+ * @return Response
+ */
+ public function setExpires(\DateTime $datetime) {}
+
+ /**
+ * Sends a Not-Modified response
+ *
+ * @return Response
+ */
+ public function setNotModified() {}
+
+ /**
+ * Sets the response content-type mime, optionally the charset
+ *
+ * $response->setContentType('application/pdf');
+ * $response->setContentType('text/plain', 'UTF-8');
+ *
+ *
+ * @param string $contentType
+ * @param string $charset
+ * @return \Phalcon\Http\Response
+ */
+ public function setContentType($contentType, $charset = null) {}
+
+ /**
+ * Set a custom ETag
+ *
+ * $response->setEtag(md5(time()));
+ *
+ *
+ * @param string $etag
+ * @return Response
+ */
+ public function setEtag($etag) {}
+
+ /**
+ * Redirect by HTTP to another action or URL
+ *
+ * //Using a string redirect (internal/external)
+ * $response->redirect("posts/index");
+ * $response->redirect("http://en.wikipedia.org", true);
+ * $response->redirect("http://www.example.com/new-location", true, 301);
+ * //Making a redirection based on a named route
+ * $response->redirect(array(
+ * "for" => "index-lang",
+ * "lang" => "jp",
+ * "controller" => "index"
+ * ));
+ *
+ *
+ * @param string|array $location
+ * @param boolean $externalRedirect
+ * @param int $statusCode
+ * @return \Phalcon\Http\Response
+ */
+ public function redirect($location = null, $externalRedirect = false, $statusCode = 302) {}
+
+ /**
+ * Sets HTTP response body
+ *
+ * response->setContent("Hello!
");
+ *
+ *
+ * @param string $content
+ * @return Response
+ */
+ public function setContent($content) {}
+
+ /**
+ * Sets HTTP response body. The parameter is automatically converted to JSON
+ *
+ * $response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param mixed $content
+ * @param int $jsonOptions
+ * @param mixed $depth
+ * @return \Phalcon\Http\Response
+ */
+ public function setJsonContent($content, $jsonOptions = 0, $depth = 512) {}
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\Response
+ */
+ public function appendContent($content) {}
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Check if the response is already sent
+ *
+ * @return bool
+ */
+ public function isSent() {}
+
+ /**
+ * Sends headers to the client
+ *
+ * @return Response
+ */
+ public function sendHeaders() {}
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return Response
+ */
+ public function sendCookies() {}
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return Response
+ */
+ public function send() {}
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @param mixed $attachment
+ * @return \Phalcon\Http\Response
+ */
+ public function setFileToSend($filePath, $attachmentName = null, $attachment = true) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/http/ResponseInterface.php b/ide/2.0.5/Phalcon/http/ResponseInterface.php
new file mode 100644
index 000000000..36f157f32
--- /dev/null
+++ b/ide/2.0.5/Phalcon/http/ResponseInterface.php
@@ -0,0 +1,150 @@
+
+ * response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function setJsonContent($content);
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function appendContent($content);
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent();
+
+ /**
+ * Sends headers to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendHeaders();
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendCookies();
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return ResponseInterface
+ */
+ public function send();
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @return ResponseInterface
+ */
+ public function setFileToSend($filePath, $attachmentName = null);
+
+}
diff --git a/ide/2.0.5/Phalcon/http/cookie/Exception.php b/ide/2.0.5/Phalcon/http/cookie/Exception.php
new file mode 100644
index 000000000..a3dbbd67d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/http/cookie/Exception.php
@@ -0,0 +1,12 @@
+
+ * class PostsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function uploadAction()
+ * {
+ * //Check if the user has uploaded files
+ * if ($this->request->hasFiles() == true) {
+ * //Print the real file names and their sizes
+ * foreach ($this->request->getUploadedFiles() as $file){
+ * echo $file->getName(), " ", $file->getSize(), "\n";
+ * }
+ * }
+ * }
+ * }
+ *
+ */
+class File implements \Phalcon\Http\Request\FileInterface
+{
+
+ protected $_name;
+
+
+ protected $_tmp;
+
+
+ protected $_size;
+
+
+ protected $_type;
+
+
+ protected $_realType;
+
+
+ protected $_error;
+
+
+ protected $_key;
+
+
+ protected $_extension;
+
+
+
+ public function getError() {}
+
+
+ public function getKey() {}
+
+
+ public function getExtension() {}
+
+ /**
+ * Phalcon\Http\Request\File constructor
+ *
+ * @param array $file
+ * @param mixed $key
+ */
+ public function __construct($file, $key = null) {}
+
+ /**
+ * Returns the file size of the uploaded file
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Returns the real name of the uploaded file
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Returns the temporal name of the uploaded file
+ *
+ * @return string
+ */
+ public function getTempName() {}
+
+ /**
+ * Returns the mime type reported by the browser
+ * This mime type is not completely secure, use getRealType() instead
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Gets the real mime type of the upload file using finfo
+ *
+ * @return string
+ */
+ public function getRealType() {}
+
+ /**
+ * Checks whether the file has been uploaded via Post.
+ *
+ * @return bool
+ */
+ public function isUploadedFile() {}
+
+ /**
+ * Moves the temporary file to a destination within the application
+ *
+ * @param string $destination
+ * @return bool
+ */
+ public function moveTo($destination) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/http/request/FileInterface.php b/ide/2.0.5/Phalcon/http/request/FileInterface.php
new file mode 100644
index 000000000..3e3109e86
--- /dev/null
+++ b/ide/2.0.5/Phalcon/http/request/FileInterface.php
@@ -0,0 +1,64 @@
+
+ * $image = new Phalcon\Image\Adapter\Imagick("upload/test.jpg");
+ * $image->resize(200, 200)->rotate(90)->crop(100, 100);
+ * if ($image->save()) {
+ * echo 'success';
+ * }
+ *
+ */
+class Imagick extends \Phalcon\Image\Adapter implements \Phalcon\Image\AdapterInterface
+{
+
+ static protected $_version = 0;
+
+
+ static protected $_checked = false;
+
+
+ /**
+ * Checks if Imagick is enabled
+ *
+ * @return bool
+ */
+ public static function check() {}
+
+ /**
+ * \Phalcon\Image\Adapter\Imagick constructor
+ *
+ * @param string $file
+ * @param int $width
+ * @param int $height
+ */
+ public function __construct($file, $width = null, $height = null) {}
+
+ /**
+ * Execute a resize.
+ *
+ * @param int $width
+ * @param int $height
+ */
+ protected function _resize($width, $height) {}
+
+ /**
+ * This method scales the images using liquid rescaling method. Only support Imagick
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $deltaX
+ * @param int $rigidity
+ * @param int $$width new width
+ * @param int $$height new height
+ * @param int $$deltaX How much the seam can traverse on x-axis. Passing 0 causes the seams to be straight.
+ * @param int $$rigidity Introduces a bias for non-straight seams. This parameter is typically 0.
+ */
+ protected function _liquidRescale($width, $height, $deltaX, $rigidity) {}
+
+ /**
+ * Execute a crop.
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $offsetX
+ * @param int $offsetY
+ */
+ protected function _crop($width, $height, $offsetX, $offsetY) {}
+
+ /**
+ * Execute a rotation.
+ *
+ * @param int $degrees
+ */
+ protected function _rotate($degrees) {}
+
+ /**
+ * Execute a flip.
+ *
+ * @param int $direction
+ */
+ protected function _flip($direction) {}
+
+ /**
+ * Execute a sharpen.
+ *
+ * @param int $amount
+ */
+ protected function _sharpen($amount) {}
+
+ /**
+ * Execute a reflection.
+ *
+ * @param int $height
+ * @param int $opacity
+ * @param bool $fadeIn
+ */
+ protected function _reflection($height, $opacity, $fadeIn) {}
+
+ /**
+ * Execute a watermarking.
+ *
+ * @param mixed $image
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ */
+ protected function _watermark(\Phalcon\Image\Adapter $image, $offsetX, $offsetY, $opacity) {}
+
+ /**
+ * Execute a text
+ *
+ * @param string $text
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $size
+ * @param string $fontfile
+ */
+ protected function _text($text, $offsetX, $offsetY, $opacity, $r, $g, $b, $size, $fontfile) {}
+
+ /**
+ * Composite one image onto another
+ *
+ * @param mixed $image
+ * @param Adapter $$mask mask Image instance
+ */
+ protected function _mask(\Phalcon\Image\Adapter $image) {}
+
+ /**
+ * Execute a background.
+ *
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $opacity
+ */
+ protected function _background($r, $g, $b, $opacity) {}
+
+ /**
+ * Blur image
+ *
+ * @param int $radius
+ * @param int $$radius Blur radius
+ */
+ protected function _blur($radius) {}
+
+ /**
+ * Pixelate image
+ *
+ * @param int $amount
+ * @param int $$amount amount to pixelate
+ */
+ protected function _pixelate($amount) {}
+
+ /**
+ * Execute a save.
+ *
+ * @param string $file
+ * @param int $quality
+ */
+ protected function _save($file, $quality) {}
+
+ /**
+ * Execute a render.
+ *
+ * @param string $extension
+ * @param int $quality
+ * @return string
+ */
+ protected function _render($extension, $quality) {}
+
+ /**
+ * Destroys the loaded image to free up resources.
+ */
+ public function __destruct() {}
+
+ /**
+ * Get instance
+ *
+ * @return \Imagick
+ */
+ public function getInternalImInstance() {}
+
+ /**
+ * Sets the limit for a particular resource in megabytes
+ *
+ * @param int $type Refer to the list of resourcetype constants (@see http://php.net/manual/ru/imagick.constants.php#imagick.constants.resourcetypes.)
+ * @param int $limit The resource limit. The unit depends on the type of the resource being limited.
+ */
+ public function setResourceLimit($type, $limit) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/loader/Exception.php b/ide/2.0.5/Phalcon/loader/Exception.php
new file mode 100644
index 000000000..0732e2934
--- /dev/null
+++ b/ide/2.0.5/Phalcon/loader/Exception.php
@@ -0,0 +1,12 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ * $logger->close();
+ *
+ */
+class File extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_fileHandler;
+
+ /**
+ * File Path
+ */
+ protected $_path;
+
+ /**
+ * Path options
+ */
+ protected $_options;
+
+
+ /**
+ * File Path
+ */
+ public function getPath() {}
+
+ /**
+ * Phalcon\Logger\Adapter\File constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the file itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Opens the internal file handler after unserialization
+ */
+ public function __wakeup() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/logger/adapter/Firephp.php b/ide/2.0.5/Phalcon/logger/adapter/Firephp.php
new file mode 100644
index 000000000..8066f6805
--- /dev/null
+++ b/ide/2.0.5/Phalcon/logger/adapter/Firephp.php
@@ -0,0 +1,52 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Firephp("");
+ * $logger->log(\Phalcon\Logger::ERROR, "This is an error");
+ * $logger->error("This is another error");
+ *
+ */
+class Firephp extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ static private $_initialized;
+
+
+ static private $_index;
+
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @see http://www.firephp.org/Wiki/Reference/Protocol
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param string $$message
+ * @param int $$type
+ * @param int $$time
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/logger/adapter/Stream.php b/ide/2.0.5/Phalcon/logger/adapter/Stream.php
new file mode 100644
index 000000000..dd26d9015
--- /dev/null
+++ b/ide/2.0.5/Phalcon/logger/adapter/Stream.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Stream("php://stderr");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Stream extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_stream;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Stream constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/logger/adapter/Syslog.php b/ide/2.0.5/Phalcon/logger/adapter/Syslog.php
new file mode 100644
index 000000000..cc0eb1569
--- /dev/null
+++ b/ide/2.0.5/Phalcon/logger/adapter/Syslog.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Syslog("ident", array(
+ * 'option' => LOG_NDELAY,
+ * 'facility' => LOG_MAIL
+ * ));
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Syslog extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ protected $_opened = false;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Syslog constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\Formatter\Syslog
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return boolean
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/logger/formatter/Firephp.php b/ide/2.0.5/Phalcon/logger/formatter/Firephp.php
new file mode 100644
index 000000000..567c7aee9
--- /dev/null
+++ b/ide/2.0.5/Phalcon/logger/formatter/Firephp.php
@@ -0,0 +1,71 @@
+
+ * class Application extends \Phalcon\Mvc\Application
+ * {
+ * /
+ * Register the services here to make them general or register
+ * in the ModuleDefinition to make them module-specific
+ * \/
+ * protected function _registerServices()
+ * {
+ * }
+ * /
+ * This method registers all the modules in the application
+ * \/
+ * public function main()
+ * {
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ * }
+ * }
+ * $application = new Application();
+ * $application->main();
+ *
+ */
+class Application extends \Phalcon\Di\Injectable
+{
+
+ protected $_defaultModule;
+
+
+ protected $_modules;
+
+
+ protected $_implicitView = true;
+
+
+ /**
+ * Phalcon\Mvc\Application
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * By default. The view is implicitly buffering all the output
+ * You can full disable the view component using this method
+ *
+ * @param bool $implicitView
+ * @return Application
+ */
+ public function useImplicitView($implicitView) {}
+
+ /**
+ * Register an array of modules present in the application
+ *
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ * @param bool $merge
+ * @return Application
+ */
+ public function registerModules($modules, $merge = false) {}
+
+ /**
+ * Return the modules registered in the application
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Gets the module definition registered in the application via module name
+ *
+ * @param string $name
+ * @return array|object
+ */
+ public function getModule($name) {}
+
+ /**
+ * Sets the module name to be used if the router doesn't return a valid module
+ *
+ * @param string $defaultModule
+ * @return Application
+ */
+ public function setDefaultModule($defaultModule) {}
+
+ /**
+ * Returns the default module name
+ *
+ * @return string
+ */
+ public function getDefaultModule() {}
+
+ /**
+ * Handles a MVC request
+ *
+ * @param string $uri
+ * @return \Phalcon\Http\ResponseInterface|boolean
+ */
+ public function handle($uri = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/Collection.php b/ide/2.0.5/Phalcon/mvc/Collection.php
new file mode 100644
index 000000000..fb2862f2e
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/Collection.php
@@ -0,0 +1,509 @@
+
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns a cloned collection
+ *
+ * @param mixed $collection
+ * @param array $document
+ * @return CollectionInterface
+ */
+ public static function cloneResult(CollectionInterface $collection, $document) {}
+
+ /**
+ * Returns a collection resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @param boolean $unique
+ * @return array
+ */
+ protected static function _getResultset($params, CollectionInterface $collection, $connection, $unique) {}
+
+ /**
+ * Perform a count over a resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @return int
+ */
+ protected static function _getGroupResultset($params, Collection $collection, $connection) {}
+
+ /**
+ * Executes internal hooks before save a document
+ *
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @param boolean $disableEvents
+ * @param boolean $exists
+ * @return boolean
+ */
+ protected final function _preSave($dependencyInjector, $disableEvents, $exists) {}
+
+ /**
+ * Executes internal events after save a document
+ *
+ * @param bool $disableEvents
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected final function _postSave($disableEvents, $success, $exists) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Fires an internal event
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an internal event that cancels the operation
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ *
+ * @param bool $disableEvents
+ * @return bool
+ */
+ protected function _cancelOperation($disableEvents) {}
+
+ /**
+ * Checks if the document exists in the collection
+ *
+ * @param \MongoCollection $collection
+ * @return boolean
+ */
+ protected function _exists($collection) {}
+
+ /**
+ * Returns all the validation messages
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if ($this->name == 'Peter') {
+ * message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Creates/Updates a collection based on the values in the atributes
+ *
+ * @return bool
+ */
+ public function save() {}
+
+ /**
+ * Find a document by its id (_id)
+ *
+ * @param string|\MongoId $id
+ * @return \Phalcon\Mvc\Collection
+ */
+ public static function findById($id) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in the robots table?
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name, "\n";
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "The first mechanical robot name is ", $robot->name, "\n";
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array(
+ * array("type" => "mechanical"),
+ * "order" => array("name" => 1)
+ * ));
+ * echo "The first virtual robot name is ", $robot->name, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ * //How many mechanical robots are there?
+ * $robots = Robots::find(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "There are ", count(robots), "\n";
+ * //Get and print virtual robots ordered by name
+ * $robots = Robots::findFirst(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1)
+ * ));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1),
+ * "limit" => 100
+ * ));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Perform a count over a collection
+ *
+ * echo 'There are ', Robots::count(), ' robots';
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Perform an aggregation using the Mongo aggregation framework
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function aggregate($parameters = null) {}
+
+ /**
+ * Allows to perform a summatory group for a column in the collection
+ *
+ * @param string $field
+ * @param mixed $conditions
+ * @param mixed $finalize
+ * @return array
+ */
+ public static function summatory($field, $conditions = null, $finalize = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ * $robot = Robots::findFirst();
+ * $robot->delete();
+ * foreach (Robots::find() as $robot) {
+ * $robot->delete();
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+ * Sets up a behavior in a collection
+ *
+ * @param mixed $behavior
+ */
+ protected function addBehavior(\Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r($robot->toArray());
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Serializes the object ignoring connections or protected properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/CollectionInterface.php b/ide/2.0.5/Phalcon/mvc/CollectionInterface.php
new file mode 100644
index 000000000..d77779a0d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/CollectionInterface.php
@@ -0,0 +1,148 @@
+
+ * dispatcher->forward(array('controller' => 'people', 'action' => 'index'));
+ * }
+ * }
+ *
+ */
+abstract class Controller extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ControllerInterface
+{
+
+ /**
+ * Phalcon\Mvc\Controller constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/ControllerInterface.php b/ide/2.0.5/Phalcon/mvc/ControllerInterface.php
new file mode 100644
index 000000000..a46083149
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/ControllerInterface.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Mvc\Dispatcher();
+ * $dispatcher->setDI($di);
+ * $dispatcher->setControllerName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $controller = $dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher implements \Phalcon\Mvc\DispatcherInterface
+{
+
+ protected $_handlerSuffix = "Controller";
+
+
+ protected $_defaultHandler = "index";
+
+
+ protected $_defaultAction = "index";
+
+
+ /**
+ * Sets the default controller suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the controller name to be dispatched
+ *
+ * @param string $controllerName
+ */
+ public function setControllerName($controllerName) {}
+
+ /**
+ * Gets last dispatched controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets previous dispatched controller name
+ *
+ * @return string
+ */
+ public function getPreviousControllerName() {}
+
+ /**
+ * Gets previous dispatched action name
+ *
+ * @return string
+ */
+ public function getPreviousActionName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Possible controller class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getControllerClass() {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getLastController() {}
+
+ /**
+ * Returns the active controller in the dispatcher
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getActiveController() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/DispatcherInterface.php b/ide/2.0.5/Phalcon/mvc/DispatcherInterface.php
new file mode 100644
index 000000000..d232517a7
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/DispatcherInterface.php
@@ -0,0 +1,54 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $app->get('/say/welcome/{name}', function ($name) {
+ * echo "
+ * $app['request'] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $alias
+ * @param mixed $definition
+ */
+ public function offsetSet($alias, $definition) {}
+
+ /**
+ * Allows to obtain a shared service in the internal services container using the array syntax
+ *
+ * var_dump($di['request']);
+ *
+ *
+ * @param string $alias
+ * @return mixed
+ */
+ public function offsetGet($alias) {}
+
+ /**
+ * Removes a service from the internal services container using the array syntax
+ *
+ * @param string $alias
+ */
+ public function offsetUnset($alias) {}
+
+ /**
+ * Appends a before middleware to be called before execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function before($handler) {}
+
+ /**
+ * Appends an 'after' middleware to be called after execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function after($handler) {}
+
+ /**
+ * Appends a 'finish' middleware to be called when the request is finished
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function finish($handler) {}
+
+ /**
+ * Returns the internal handlers attached to the application
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/Model.php b/ide/2.0.5/Phalcon/mvc/Model.php
new file mode 100644
index 000000000..edf0c695d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/Model.php
@@ -0,0 +1,1192 @@
+
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can store robots: ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ */
+abstract class Model implements \Phalcon\Mvc\EntityInterface, \Phalcon\Mvc\ModelInterface, \Phalcon\Mvc\Model\ResultInterface, \Phalcon\Di\InjectionAwareInterface, \Serializable
+{
+
+ const OP_NONE = 0;
+
+
+ const OP_CREATE = 1;
+
+
+ const OP_UPDATE = 2;
+
+
+ const OP_DELETE = 3;
+
+
+ const DIRTY_STATE_PERSISTENT = 0;
+
+
+ const DIRTY_STATE_TRANSIENT = 1;
+
+
+ const DIRTY_STATE_DETACHED = 2;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_modelsManager;
+
+
+ protected $_modelsMetaData;
+
+
+ protected $_errorMessages;
+
+
+ protected $_operationMade = 0;
+
+
+ protected $_dirtyState = 1;
+
+
+ protected $_transaction;
+
+
+ protected $_uniqueKey;
+
+
+ protected $_uniqueParams;
+
+
+ protected $_uniqueTypes;
+
+
+ protected $_skipped;
+
+
+ protected $_related;
+
+
+ protected $_snapshot;
+
+
+ /**
+ * Phalcon\Mvc\Model constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param mixed $modelsManager
+ */
+ public final function __construct(\Phalcon\DiInterface $dependencyInjector = null, \Phalcon\Mvc\Model\ManagerInterface $modelsManager = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a custom events manager
+ *
+ * @param mixed $eventsManager
+ */
+ protected function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the custom events manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ protected function getEventsManager() {}
+
+ /**
+ * Returns the models meta-data service related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\MetaDataInterface
+ */
+ public function getModelsMetaData() {}
+
+ /**
+ * Returns the models manager related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\ManagerInterface
+ */
+ public function getModelsManager() {}
+
+ /**
+ * Sets a transaction related to the Model instance
+ *
+ * use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
+ * use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
+ * try {
+ * $txManager = new TxManager();
+ * $transaction = $txManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Robot part cannot be saved");
+ * }
+ * $transaction->commit();
+ * } catch (TxFailed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ *
+ * @param mixed $transaction
+ * @return Model
+ */
+ public function setTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Sets table name which model should be mapped
+ *
+ * @param string $source
+ * @return Model
+ */
+ protected function setSource($source) {}
+
+ /**
+ * Returns table name mapped in the model
+ *
+ * @return string
+ */
+ public function getSource() {}
+
+ /**
+ * Sets schema name where table mapped is located
+ *
+ * @param string $schema
+ * @return Model
+ */
+ protected function setSchema($schema) {}
+
+ /**
+ * Returns schema name where table mapped is located
+ *
+ * @return string
+ */
+ public function getSchema() {}
+
+ /**
+ * Sets the DependencyInjection connection service name
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to read data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setReadConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to write data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setWriteConnectionService($connectionService) {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to read data related the model
+ *
+ * @return string
+ */
+ public function getReadConnectionService() {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to write data related to the model
+ *
+ * @return string
+ */
+ public function getWriteConnectionService() {}
+
+ /**
+ * Sets the dirty state of the object using one of the DIRTY_STATE_* constants
+ *
+ * @param int $dirtyState
+ * @return ModelInterface
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not
+ *
+ * @return int
+ */
+ public function getDirtyState() {}
+
+ /**
+ * Gets the connection used to read data for the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection() {}
+
+ /**
+ * Gets the connection used to write data to the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection() {}
+
+ /**
+ * Assigns values to a model from an array
+ *
+ * $robot->assign(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ * //assign by db row, column map needed
+ * $robot->assign($dbRow, array(
+ * 'db_type' => 'type',
+ * 'db_name' => 'name',
+ * 'db_year' => 'year'
+ * ));
+ * //allow assign only name and year
+ * $robot->assign($_POST, null, array('name', 'year');
+ *
+ *
+ * @param array $data
+ * @param array $dataColumnMap array to transform keys of data to another
+ * @param array $whiteList
+ * @return \Phalcon\Mvc\Model
+ */
+ public function assign($data, $dataColumnMap = null, $whiteList = null) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model.
+ *
+ * $robot = \Phalcon\Mvc\Model::cloneResultMap(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface|\Phalcon\Mvc\Model\Row $base
+ * @param array $data
+ * @param array $columnMap
+ * @param int $dirtyState
+ * @param boolean $keepSnapshots
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function cloneResultMap($base, $data, $columnMap, $dirtyState = 0, $keepSnapshots = null) {}
+
+ /**
+ * Returns an hydrated result based on the data and the column map
+ *
+ * @param array $data
+ * @param array $columnMap
+ * @param int $hydrationMode
+ * @return mixed
+ */
+ public static function cloneResultMapHydrate($data, $columnMap, $hydrationMode) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model
+ *
+ * $robot = Phalcon\Mvc\Model::cloneResult(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param mixed $base
+ * @param array $data
+ * @param int $dirtyState
+ * @param \Phalcon\Mvc\ModelInterface $$base
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public static function cloneResult(ModelInterface $base, $data, $dirtyState = 0) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ * //How many mechanical robots are there?
+ * $robots = Robots::find("type='mechanical'");
+ * echo "There are ", count($robots), "\n";
+ * //Get and print virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name", "limit" => 100));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ *
+ * @param mixed $parameters
+ * @param $array parameters
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in robots table?
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name;
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst("type='mechanical'");
+ * echo "The first mechanical robot name is ", $robot->name;
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array("type='virtual'", "order" => "name"));
+ * echo "The first virtual robot name is ", $robot->name;
+ *
+ *
+ * @param string|array $parameters
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Create a criteria for a specific model
+ *
+ * @param mixed $dependencyInjector
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public static function query(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Checks if the current record already exists or not
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _exists(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table = null) {}
+
+ /**
+ * Generate a PHQL SELECT statement for an aggregate
+ *
+ * @param string $functionName
+ * @param string $alias
+ * @param array $parameters
+ * @param string $function
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected static function _groupResult($functionName, $alias, $parameters) {}
+
+ /**
+ * Allows to count how many records match the specified conditions
+ *
+ * //How many robots are there?
+ * $number = Robots::count();
+ * echo "There are ", $number, "\n";
+ * //How many mechanical robots are there?
+ * $number = Robots::count("type='mechanical'");
+ * echo "There are ", $number, " mechanical robots\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Allows to calculate a summatory on a column that match the specified conditions
+ *
+ * //How much are all robots?
+ * $sum = Robots::sum(array('column' => 'price'));
+ * echo "The total price of robots is ", $sum, "\n";
+ * //How much are mechanical robots?
+ * $sum = Robots::sum(array("type='mechanical'", 'column' => 'price'));
+ * echo "The total price of mechanical robots is ", $sum, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function sum($parameters = null) {}
+
+ /**
+ * Allows to get the maximum value of a column that match the specified conditions
+ *
+ * //What is the maximum robot id?
+ * $id = Robots::maximum(array('column' => 'id'));
+ * echo "The maximum robot id is: ", $id, "\n";
+ * //What is the maximum id of mechanical robots?
+ * $sum = Robots::maximum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The maximum robot id of mechanical robots is ", $id, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function maximum($parameters = null) {}
+
+ /**
+ * Allows to get the minimum value of a column that match the specified conditions
+ *
+ * //What is the minimum robot id?
+ * $id = Robots::minimum(array('column' => 'id'));
+ * echo "The minimum robot id is: ", $id;
+ * //What is the minimum id of mechanical robots?
+ * $sum = Robots::minimum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The minimum robot id of mechanical robots is ", $id;
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function minimum($parameters = null) {}
+
+ /**
+ * Allows to calculate the average value on a column matching the specified conditions
+ *
+ * //What's the average price of robots?
+ * $average = Robots::average(array('column' => 'price'));
+ * echo "The average price is ", $average, "\n";
+ * //What's the average price of mechanical robots?
+ * $average = Robots::average(array("type='mechanical'", 'column' => 'price'));
+ * echo "The average price of mechanical robots is ", $average, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return double
+ */
+ public static function average($parameters = null) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ * This method stops if one of the callbacks/listeners returns boolean false
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ */
+ protected function _cancelOperation() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if ($this->name == 'Peter') {
+ * $message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage($message);
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ * @return Model
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ * @return Model
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Returns all the validation messages
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo $message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @param mixed $filter
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages($filter = null) {}
+
+ /**
+ * Reads "belongs to" relations and check the virtual foreign keys when inserting or updating records
+ * to verify that inserted/updated values are present in the related entity
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysRestrict() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (cascade) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseCascade() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (restrict) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseRestrict() {}
+
+ /**
+ * Executes internal hooks before save a record
+ *
+ * @param mixed $metaData
+ * @param bool $exists
+ * @param mixed $identityField
+ * @return bool
+ */
+ protected function _preSave(\Phalcon\Mvc\Model\MetadataInterface $metaData, $exists, $identityField) {}
+
+ /**
+ * Executes internal events after save a record
+ *
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected function _postSave($success, $exists) {}
+
+ /**
+ * Sends a pre-build INSERT SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @param boolean|string $identityField
+ * @return boolean
+ */
+ protected function _doLowInsert(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table, $identityField) {}
+
+ /**
+ * Sends a pre-build UPDATE SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetaDataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _doLowUpdate(\Phalcon\Mvc\Model\MetaDataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table) {}
+
+ /**
+ * Saves related records that must be stored prior to save the master record
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _preSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Save the related records assigned in the has-one/has-many relations
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _postSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Inserts or updates a model instance. Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->save();
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->save();
+ *
+ *
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+ */
+ public function save($data = null, $whiteList = null) {}
+
+ /**
+ * Inserts a model instance. If the instance already exists in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->create();
+ * //Passing an array to create
+ * $robot = new Robots();
+ * $robot->create(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astroy Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param mixed $data
+ * @param mixed $whiteList
+ * @return bool
+ */
+ public function create($data = null, $whiteList = null) {}
+
+ /**
+ * Updates a model instance. If the instance doesn't exist in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->update();
+ *
+ *
+ * @param mixed $data
+ * @param mixed $whiteList
+ * @return bool
+ */
+ public function update($data = null, $whiteList = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ * $robot = Robots::findFirst("id=100");
+ * $robot->delete();
+ * foreach (Robots::find("type = 'mechanical'") as $robot) {
+ * $robot->delete();
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+ * Returns the type of the latest operation performed by the ORM
+ * Returns one of the OP_* class constants
+ *
+ * @return int
+ */
+ public function getOperationMade() {}
+
+ /**
+ * Refreshes the model attributes re-querying the record from the database
+ *
+ * @return Model
+ */
+ public function refresh() {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT/UPDATE statement
+ *
+ * skipAttributes(array('price'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributes($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT statement
+ *
+ * skipAttributesOnCreate(array('created_at'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnCreate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * skipAttributesOnUpdate(array('modified_in'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnUpdate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * allowEmptyStringValues(array('name'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function allowEmptyStringValues($attributes) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * hasOne('id', 'RobotsDescription', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasOne($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse 1-1 between two models
+ *
+ * belongsTo('robots_id', 'Robots', 'id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function belongsTo($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * hasMany('id', 'RobotsParts', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasMany($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation n-n between two models through an intermediate relation
+ *
+ * hasManyToMany(
+ * 'id',
+ * 'RobotsParts',
+ * 'robots_id',
+ * 'parts_id',
+ * 'Parts',
+ * 'id'
+ * );
+ * }
+ * }
+ *
+ *
+ * @param string|array fields
+ * @param string intermediateModel
+ * @param string|array intermediateFields
+ * @param string|array intermediateReferencedFields
+ * @param string referencedModel
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referenceModel
+ * @param string|array $referencedFields
+ * @param array $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasManyToMany($fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a behavior in a model
+ *
+ * addBehavior(new Timestampable(array(
+ * 'onCreate' => array(
+ * 'field' => 'created_at',
+ * 'format' => 'Y-m-d'
+ * )
+ * )));
+ * }
+ * }
+ *
+ *
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if the model must keep the original record snapshot in memory
+ *
+ * keepSnapshots(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $keepSnapshot
+ */
+ protected function keepSnapshots($keepSnapshot) {}
+
+ /**
+ * Sets the record's snapshot data.
+ * This method is used internally to set snapshot data when the model was set up to keep snapshot data
+ *
+ * @param array $data
+ * @param array $columnMap
+ */
+ public function setSnapshotData($data, $columnMap = null) {}
+
+ /**
+ * Checks if the object has internal snapshot data
+ *
+ * @return bool
+ */
+ public function hasSnapshotData() {}
+
+ /**
+ * Returns the internal snapshot data
+ *
+ * @return array
+ */
+ public function getSnapshotData() {}
+
+ /**
+ * Check if a specific attribute has changed
+ * This only works if the model is keeping data snapshots
+ *
+ * @param string|array $fieldName
+ * @return bool
+ */
+ public function hasChanged($fieldName = null) {}
+
+ /**
+ * Returns a list of changed values
+ *
+ * @return array
+ */
+ public function getChangedFields() {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * useDynamicUpdate(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $dynamicUpdate
+ */
+ protected function useDynamicUpdate($dynamicUpdate) {}
+
+ /**
+ * Returns related records based on defined relations
+ *
+ * @param string $alias
+ * @param array $arguments
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getRelated($alias, $arguments = null) {}
+
+ /**
+ * Returns related records defined relations depending on the method name
+ *
+ * @param string $modelName
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ protected function _getRelatedRecords($modelName, $method, $arguments) {}
+
+ /**
+ * Handles method calls when a method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+ public function __call($method, $arguments) {}
+
+ /**
+ * Handles method calls when a static method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+ public static function __callStatic($method, $arguments = null) {}
+
+ /**
+ * Magic method to assign values to the the model
+ *
+ * @param string $property
+ * @param mixed $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Magic method to get related records using the relation alias as a property
+ *
+ * @param string $property
+ * @return \Phalcon\Mvc\Model\Resultset|\Phalcon\Mvc\Model
+ */
+ public function __get($property) {}
+
+ /**
+ * Magic method to check if a property is a valid relation
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Serializes the object ignoring connections, services, related objects or static properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+ /**
+ * Returns a simple representation of the object that can be used with var_dump
+ *
+ * var_dump($robot->dump());
+ *
+ *
+ * @return array
+ */
+ public function dump() {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r($robot->toArray());
+ *
+ *
+ * @param mixed $columns
+ * @param array $$columns
+ * @return array
+ */
+ public function toArray($columns = null) {}
+
+ /**
+ * Enables/disables options in the ORM
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+ /**
+ * Reset a model instance data
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/ModelInterface.php b/ide/2.0.5/Phalcon/mvc/ModelInterface.php
new file mode 100644
index 000000000..4a24901de
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/ModelInterface.php
@@ -0,0 +1,323 @@
+
+ * $router = new Router();
+ * $router->add(
+ * "/documentation/{chapter}/{name}\.{type:[a-z]+}",
+ * array(
+ * "controller" => "documentation",
+ * "action" => "show"
+ * )
+ * );
+ * $router->handle();
+ * echo $router->getControllerName();
+ *
+ */
+class Router implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\RouterInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ const URI_SOURCE_GET_URL = 0;
+
+
+ const URI_SOURCE_SERVER_REQUEST_URI = 1;
+
+
+ const POSITION_FIRST = 0;
+
+
+ const POSITION_LAST = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_eventsManager;
+
+
+ protected $_uriSource;
+
+
+ protected $_namespace = null;
+
+
+ protected $_module = null;
+
+
+ protected $_controller = null;
+
+
+ protected $_action = null;
+
+
+ protected $_params;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ protected $_defaultNamespace;
+
+
+ protected $_defaultModule;
+
+
+ protected $_defaultController;
+
+
+ protected $_defaultAction;
+
+
+ protected $_defaultParams;
+
+
+ protected $_removeExtraSlashes;
+
+
+ protected $_notFoundPaths;
+
+
+ /**
+ * Phalcon\Mvc\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the events manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Get rewrite info. This info is read from $_GET['_url']. This returns '/' if the rewrite information cannot be read
+ *
+ * @return string
+ */
+ public function getRewriteUri() {}
+
+ /**
+ * Sets the URI source. One of the URI_SOURCE_* constants
+ *
+ * $router->setUriSource(Router::URI_SOURCE_SERVER_REQUEST_URI);
+ *
+ *
+ * @param mixed $uriSource
+ * @return RouterInterface
+ */
+ public function setUriSource($uriSource) {}
+
+ /**
+ * Set whether router must remove the extra slashes in the handled routes
+ *
+ * @param bool $remove
+ * @return RouterInterface
+ */
+ public function removeExtraSlashes($remove) {}
+
+ /**
+ * Sets the name of the default namespace
+ *
+ * @param string $namespaceName
+ * @return RouterInterface
+ */
+ public function setDefaultNamespace($namespaceName) {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ * @return RouterInterface
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ * @return RouterInterface
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ * @return RouterInterface
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return RouterInterface
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Returns an array of default parameters
+ *
+ * @return array
+ */
+ public function getDefaults() {}
+
+ /**
+ * Handles routing information received from the rewrite engine
+ *
+ * //Read the info from the rewrite engine
+ * $router->handle();
+ * //Manually passing an URL
+ * $router->handle('/posts/edit/1');
+ *
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Adds a route to the router without any HTTP constraint
+ *
+ * use Phalcon\Mvc\Router;
+ * $router->add('/about', 'About::index');
+ * $router->add('/about', 'About::index', ['GET', 'POST']);
+ * $router->add('/about', 'About::index', ['GET', 'POST'], Router::POSITION_FIRST);
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Mounts a group of routes in the router
+ *
+ * @param mixed $group
+ * @return RouterInterface
+ */
+ public function mount(\Phalcon\Mvc\Router\GroupInterface $group) {}
+
+ /**
+ * Set a group of paths to be returned when none of the defined routes are matched
+ *
+ * @param mixed $paths
+ * @return RouterInterface
+ */
+ public function notFound($paths) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Returns the processed namespace name
+ *
+ * @return string
+ */
+ public function getNamespaceName() {}
+
+ /**
+ * Returns the processed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns the processed controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Returns the processed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns the processed parameters
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param mixed $id
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteByName($name) {}
+
+ /**
+ * Returns whether controller name should not be mangled
+ *
+ * @return bool
+ */
+ public function isExactControllerName() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/RouterInterface.php b/ide/2.0.5/Phalcon/mvc/RouterInterface.php
new file mode 100644
index 000000000..d649f3afb
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/RouterInterface.php
@@ -0,0 +1,212 @@
+
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ */
+class Url implements \Phalcon\Mvc\UrlInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_baseUri = null;
+
+
+ protected $_staticBaseUri = null;
+
+
+ protected $_basePath = null;
+
+
+ protected $_router;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a prefix for all the URIs to be generated
+ *
+ * $url->setBaseUri('/invo/');
+ * $url->setBaseUri('/invo/index.php/');
+ *
+ *
+ * @param string $baseUri
+ * @return Url
+ */
+ public function setBaseUri($baseUri) {}
+
+ /**
+ * Sets a prefix for all static URLs generated
+ *
+ * $url->setStaticBaseUri('/invo/');
+ *
+ *
+ * @param string $staticBaseUri
+ * @return Url
+ */
+ public function setStaticBaseUri($staticBaseUri) {}
+
+ /**
+ * Returns the prefix for all the generated urls. By default /
+ *
+ * @return string
+ */
+ public function getBaseUri() {}
+
+ /**
+ * Returns the prefix for all the generated static urls. By default /
+ *
+ * @return string
+ */
+ public function getStaticBaseUri() {}
+
+ /**
+ * Sets a base path for all the generated paths
+ *
+ * $url->setBasePath('/var/www/htdocs/');
+ *
+ *
+ * @param string $basePath
+ * @return Url
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Returns the base path
+ *
+ * @return string
+ */
+ public function getBasePath() {}
+
+ /**
+ * Generates a URL
+ *
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2015'));
+ *
+ *
+ * @param mixed $uri
+ * @param mixed $args
+ * @param mixed $local
+ * @param mixed $baseUri
+ * @return string
+ */
+ public function get($uri = null, $args = null, $local = null, $baseUri = null) {}
+
+ /**
+ * Generates a URL for a static resource
+ *
+ * // Generate a URL for a static resource
+ * echo $url->getStatic("img/logo.png");
+ * // Generate a URL for a static predefined route
+ * echo $url->getStatic(array('for' => 'logo-cdn'));
+ *
+ *
+ * @param mixed $uri
+ * @return string
+ */
+ public function getStatic($uri = null) {}
+
+ /**
+ * Generates a local path
+ *
+ * @param string $path
+ * @return string
+ */
+ public function path($path = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/UrlInterface.php b/ide/2.0.5/Phalcon/mvc/UrlInterface.php
new file mode 100644
index 000000000..9d35e888c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/UrlInterface.php
@@ -0,0 +1,59 @@
+
+ * //Setting views directory
+ * $view = new \Phalcon\Mvc\View();
+ * $view->setViewsDir('app/views/');
+ * $view->start();
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->render('posts', 'recent');
+ * $view->finish();
+ * //Printing views output
+ * echo $view->getContent();
+ *
+ */
+class View extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewInterface
+{
+ /**
+ * Render Level: To the main layout
+ */
+ const LEVEL_MAIN_LAYOUT = 5;
+
+ /**
+ * Render Level: Render to the templates "after"
+ */
+ const LEVEL_AFTER_TEMPLATE = 4;
+
+ /**
+ * Render Level: Hasta el layout del controlador
+ */
+ const LEVEL_LAYOUT = 3;
+
+ /**
+ * Render Level: To the templates "before"
+ */
+ const LEVEL_BEFORE_TEMPLATE = 2;
+
+ /**
+ * Render Level: To the action view
+ */
+ const LEVEL_ACTION_VIEW = 1;
+
+ /**
+ * Render Level: No render any view
+ */
+ const LEVEL_NO_RENDER = 0;
+
+ /**
+ * Cache Mode
+ */
+ const CACHE_MODE_NONE = 0;
+
+
+ const CACHE_MODE_INVERSE = 1;
+
+
+ protected $_options;
+
+
+ protected $_basePath = "";
+
+
+ protected $_content = "";
+
+
+ protected $_renderLevel = 5;
+
+
+ protected $_currentRenderLevel = 0;
+
+
+ protected $_disabledLevels;
+
+
+ protected $_viewParams;
+
+
+ protected $_layout;
+
+
+ protected $_layoutsDir = "";
+
+
+ protected $_partialsDir = "";
+
+
+ protected $_viewsDir;
+
+
+ protected $_templatesBefore;
+
+
+ protected $_templatesAfter;
+
+
+ protected $_engines = false;
+
+ /**
+ * @var array
+ */
+ protected $_registeredEngines;
+
+
+ protected $_mainView = "index";
+
+
+ protected $_controllerName;
+
+
+ protected $_actionName;
+
+
+ protected $_params;
+
+
+ protected $_pickView;
+
+
+ protected $_cache;
+
+
+ protected $_cacheLevel = 0;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_disabled = false;
+
+
+
+ public function getRenderLevel() {}
+
+
+ public function getCurrentRenderLevel() {}
+
+ /**
+ * @return array
+ */
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ * @return View
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setLayoutsDir('../common/layouts/');
+ *
+ *
+ * @param string $layoutsDir
+ * @return View
+ */
+ public function setLayoutsDir($layoutsDir) {}
+
+ /**
+ * Gets the current layouts sub-directory
+ *
+ * @return string
+ */
+ public function getLayoutsDir() {}
+
+ /**
+ * Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setPartialsDir('../common/partials/');
+ *
+ *
+ * @param string $partialsDir
+ * @return View
+ */
+ public function setPartialsDir($partialsDir) {}
+
+ /**
+ * Gets the current partials sub-directory
+ *
+ * @return string
+ */
+ public function getPartialsDir() {}
+
+ /**
+ * Sets base path. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setBasePath(__DIR__ . '/');
+ *
+ *
+ * @param string $basePath
+ * @return View
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Gets base path
+ *
+ * @return string
+ */
+ public function getBasePath() {}
+
+ /**
+ * Sets the render level for the view
+ *
+ * //Render the view related to the controller only
+ * $this->view->setRenderLevel(View::LEVEL_VIEW);
+ *
+ *
+ * @param int $level
+ * @return View
+ */
+ public function setRenderLevel($level) {}
+
+ /**
+ * Disables a specific level of rendering
+ *
+ * //Render all levels except ACTION level
+ * $this->view->disableLevel(View::LEVEL_ACTION_VIEW);
+ *
+ *
+ * @param int|array $level
+ * @return \Phalcon\Mvc\View
+ */
+ public function disableLevel($level) {}
+
+ /**
+ * Sets default view name. Must be a file without extension in the views directory
+ *
+ * //Renders as main view views-dir/base.phtml
+ * $this->view->setMainView('base');
+ *
+ *
+ * @param string $viewPath
+ * @return View
+ */
+ public function setMainView($viewPath) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getMainView() {}
+
+ /**
+ * Change the layout to be used instead of using the name of the latest controller name
+ *
+ * $this->view->setLayout('main');
+ *
+ *
+ * @param string $layout
+ * @return View
+ */
+ public function setLayout($layout) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getLayout() {}
+
+ /**
+ * Sets a template before the controller layout
+ *
+ * @param string|array $templateBefore
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateBefore($templateBefore) {}
+
+ /**
+ * Resets any "template before" layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateBefore() {}
+
+ /**
+ * Sets a "template after" controller layout
+ *
+ * @param string|array $templateAfter
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateAfter($templateAfter) {}
+
+ /**
+ * Resets any template before layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateAfter() {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param boolean $merge
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Gets the name of the controller rendered
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets the name of the action rendered
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Gets extra parameters of the action rendered
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Starts rendering process enabling the output buffering
+ *
+ * @return View
+ */
+ public function start() {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Checks whether view exists on registered extensions and render it
+ *
+ * @param array $engines
+ * @param string $viewPath
+ * @param boolean $silence
+ * @param boolean $mustClean
+ * @param mixed $cache
+ * @param \Phalcon\Cache\BackendInterface $$cache
+ */
+ protected function _engineRender($engines, $viewPath, $silence, $mustClean, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ * @return View
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Checks whether view exists
+ *
+ * @param string $view
+ * @return bool
+ */
+ public function exists($view) {}
+
+ /**
+ * Executes render process from dispatching data
+ *
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->start()->render('posts', 'recent')->finish();
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @return bool|View
+ */
+ public function render($controllerName, $actionName, $params = null) {}
+
+ /**
+ * Choose a different view to render instead of last-controller/last-action
+ *
+ * class ProductsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function saveAction()
+ * {
+ * //Do some save stuff...
+ * //Then show the list view
+ * $this->view->pick("products/list");
+ * }
+ * }
+ *
+ *
+ * @param string|array $renderView
+ * @return \Phalcon\Mvc\View
+ */
+ public function pick($renderView) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Retrieve the contents of a partial
+ * echo $this->getPartial('shared/footer');
+ *
+ *
+ * //Retrieve the contents of a partial with arguments
+ * echo $this->getPartial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ * @return string
+ */
+ public function getPartial($partialPath, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Perform the automatic rendering returning the output as a string
+ *
+ * $template = $this->view->getRender('products', 'show', array('products' => $products));
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @param mixed $configCallback
+ * @return string
+ */
+ public function getRender($controllerName, $actionName, $params = null, $configCallback = null) {}
+
+ /**
+ * Finishes the render process by stopping the output buffering
+ *
+ * @return View
+ */
+ public function finish() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Check if the component is currently caching the output content
+ *
+ * @return bool
+ */
+ public function isCaching() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param boolean|array $options
+ * @return \Phalcon\Mvc\View
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return View
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Disables the auto-rendering process
+ *
+ * @return View
+ */
+ public function disable() {}
+
+ /**
+ * Enables the auto-rendering process
+ *
+ * @return View
+ */
+ public function enable() {}
+
+ /**
+ * Resets the view component to its factory default values
+ *
+ * @return View
+ */
+ public function reset() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+ /**
+ * Whether automatic rendering is enabled
+ *
+ * @return bool
+ */
+ public function isDisabled() {}
+
+ /**
+ * Magic method to retrieve if a variable is set in the view
+ *
+ * echo isset($this->view->products);
+ *
+ *
+ * @param string $key
+ * @return boolean
+ */
+ public function __isset($key) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/ViewBaseInterface.php b/ide/2.0.5/Phalcon/mvc/ViewBaseInterface.php
new file mode 100644
index 000000000..237308125
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/ViewBaseInterface.php
@@ -0,0 +1,86 @@
+x or array[x].
+ */
+class Document implements \Phalcon\Mvc\EntityInterface, \ArrayAccess
+{
+
+ /**
+ * Checks whether an offset exists in the document
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Returns the value of a field using the ArrayAccess interfase
+ *
+ * @param string $index
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Change a value using the ArrayAccess interface
+ *
+ * @param string $index
+ * @param mixed $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/collection/Exception.php b/ide/2.0.5/Phalcon/mvc/collection/Exception.php
new file mode 100644
index 000000000..736016ca9
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/collection/Exception.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $di->set('collectionManager', function(){
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized;
+
+
+ protected $_lastInitialized;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_connectionServices;
+
+
+ protected $_implicitObjectsIds;
+
+
+ protected $_behaviors;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService) {}
+
+ /**
+ * Sets whether a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds) {}
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Mongo
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ * @return bool
+ */
+ public function missingMethod(\Phalcon\Mvc\CollectionInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/collection/ManagerInterface.php b/ide/2.0.5/Phalcon/mvc/collection/ManagerInterface.php
new file mode 100644
index 000000000..b51756b49
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/collection/ManagerInterface.php
@@ -0,0 +1,108 @@
+
+ * $di = new \Phalcon\Di();
+ * $di->set('collectionManager', function() {
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * $robot = new Robots(di);
+ *
+ */
+interface ManagerInterface
+{
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager);
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName);
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized();
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService);
+
+ /**
+ * Sets if a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds);
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Binds a behavior to a collection
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior);
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/collection/behavior/SoftDelete.php b/ide/2.0.5/Phalcon/mvc/collection/behavior/SoftDelete.php
new file mode 100644
index 000000000..527ee606b
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/collection/behavior/SoftDelete.php
@@ -0,0 +1,21 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $collection = new Collection();
+ * $collection->setHandler(new PostsController());
+ * $collection->get('/posts/edit/{id}', 'edit');
+ * $app->mount($collection);
+ *
+ */
+class Collection implements \Phalcon\Mvc\Micro\CollectionInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_lazy;
+
+
+ protected $_handler;
+
+
+ protected $_handlers;
+
+
+ /**
+ * Internal function to add a handler to the group
+ *
+ * @param string|array $method
+ * @param string $routePattern
+ * @param mixed $handler
+ * @param string $name
+ */
+ protected function _addMap($method, $routePattern, $handler, $name) {}
+
+ /**
+ * Sets a prefix for all routes added to the collection
+ *
+ * @param string $prefix
+ * @return Collection
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the collection prefix if any
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Returns the registered handlers
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+ /**
+ * Sets the main handler
+ *
+ * @param mixed $handler
+ * @param boolean $lazy
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function setHandler($handler, $lazy = false) {}
+
+ /**
+ * Sets if the main handler must be lazy loaded
+ *
+ * @param bool $lazy
+ * @return Collection
+ */
+ public function setLazy($lazy) {}
+
+ /**
+ * Returns if the main handler must be lazy loaded
+ *
+ * @return bool
+ */
+ public function isLazy() {}
+
+ /**
+ * Returns the main handler
+ *
+ * @return mixed
+ */
+ public function getHandler() {}
+
+ /**
+ * Maps a route to a handler
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function map($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is GET
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function get($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is POST
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function post($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PUT
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function put($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PATCH
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function patch($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is HEAD
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function head($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is DELETE
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function delete($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is OPTIONS
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param mixed $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function options($routePattern, $handler, $name = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/micro/CollectionInterface.php b/ide/2.0.5/Phalcon/mvc/micro/CollectionInterface.php
new file mode 100644
index 000000000..30c219445
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/micro/CollectionInterface.php
@@ -0,0 +1,145 @@
+
+ * $robots = Robots::query()
+ * ->where("type = :type:")
+ * ->andWhere("year < 2000")
+ * ->bind(array("type" => "mechanical"))
+ * ->limit(5, 10)
+ * ->orderBy("name")
+ * ->execute();
+ *
+ */
+class Criteria implements \Phalcon\Mvc\Model\CriteriaInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_model;
+
+
+ protected $_params;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return null|\Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set a model on which the query will be executed
+ *
+ * @param string $modelName
+ * @return Criteria
+ */
+ public function setModelName($modelName) {}
+
+ /**
+ * Returns an internal model name on which the criteria will be applied
+ *
+ * @return string
+ */
+ public function getModelName() {}
+
+ /**
+ * Sets the bound parameters in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindParams
+ * @return Criteria
+ */
+ public function bind($bindParams) {}
+
+ /**
+ * Sets the bind types in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindTypes
+ * @return Criteria
+ */
+ public function bindTypes($bindTypes) {}
+
+ /**
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param mixed $distinct
+ * @return Criteria
+ */
+ public function distinct($distinct) {}
+
+ /**
+ * Sets the columns to be queried
+ *
+ * $criteria->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function columns($columns) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->join('Robots');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'LEFT');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @param mixed $type
+ * @return Criteria
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->innerJoin('Robots');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $criteria->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $criteria->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the conditions parameter in the criteria
+ *
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator (deprecated)
+ *
+ * @deprecated 1.0.0
+ * @see \Phalcon\Mvc\Model\Criteria::andWhere()
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function addWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator
+ *
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an OR operator
+ *
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Criteria
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Criteria
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Adds the conditions parameter to the criteria
+ *
+ * @param string $conditions
+ * @return Criteria
+ */
+ public function conditions($conditions) {}
+
+ /**
+ * Adds the order-by parameter to the criteria (deprecated)
+ *
+ * @deprecated 1.2.1
+ * @see \Phalcon\Mvc\Model\Criteria::orderBy()
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function order($orderColumns) {}
+
+ /**
+ * Adds the order-by clause to the criteria
+ *
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function orderBy($orderColumns) {}
+
+ /**
+ * Adds the group-by clause to the criteria
+ *
+ * @param mixed $group
+ * @return Criteria
+ */
+ public function groupBy($group) {}
+
+ /**
+ * Adds the having clause to the criteria
+ *
+ * @param mixed $having
+ * @return Criteria
+ */
+ public function having($having) {}
+
+ /**
+ * Adds the limit parameter to the criteria
+ *
+ * @param mixed $limit
+ * @param mixed $offset
+ * @return Criteria
+ */
+ public function limit($limit, $offset = null) {}
+
+ /**
+ * Adds the "for_update" parameter to the criteria
+ *
+ * @param bool $forUpdate
+ * @return Criteria
+ */
+ public function forUpdate($forUpdate = true) {}
+
+ /**
+ * Adds the "shared_lock" parameter to the criteria
+ *
+ * @param bool $sharedLock
+ * @return Criteria
+ */
+ public function sharedLock($sharedLock = true) {}
+
+ /**
+ * Sets the cache options in the criteria
+ * This method replaces all previously set cache options
+ *
+ * @param array $cache
+ * @return Criteria
+ */
+ public function cache($cache) {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere() {}
+
+ /**
+ * Returns the columns to be queried
+ *
+ * @return string|array|null
+ */
+ public function getColumns() {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions() {}
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit() {}
+
+ /**
+ * Returns the order clause in the criteria
+ *
+ * @return string|null
+ */
+ public function getOrder() {}
+
+ /**
+ * Returns the group clause in the criteria
+ */
+ public function getGroupBy() {}
+
+ /**
+ * Returns the having clause in the criteria
+ */
+ public function getHaving() {}
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return Criteria
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data) {}
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function execute() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/CriteriaInterface.php b/ide/2.0.5/Phalcon/mvc/model/CriteriaInterface.php
new file mode 100644
index 000000000..495a337b3
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/CriteriaInterface.php
@@ -0,0 +1,219 @@
+
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function betweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function inWhere($expr, $values);
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function notInWhere($expr, $values);
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere();
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions();
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit();
+
+ /**
+ * Returns the order parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getOrder();
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams();
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return CriteriaInterface
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data);
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return ResultsetInterface
+ */
+ public function execute();
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/Exception.php b/ide/2.0.5/Phalcon/mvc/model/Exception.php
new file mode 100644
index 000000000..1685da6d4
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/Exception.php
@@ -0,0 +1,12 @@
+
+ * use Phalcon\DI;
+ * use Phalcon\Mvc\Model\Manager as ModelsManager;
+ * $di = new DI();
+ * $di->set('modelsManager', function() {
+ * return new ModelsManager();
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\ManagerInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_readConnectionServices;
+
+
+ protected $_writeConnectionServices;
+
+
+ protected $_aliases;
+
+ /**
+ * Has many relations
+ */
+ protected $_hasMany;
+
+ /**
+ * Has many relations by model
+ */
+ protected $_hasManySingle;
+
+ /**
+ * Has one relations
+ */
+ protected $_hasOne;
+
+ /**
+ * Has one relations by model
+ */
+ protected $_hasOneSingle;
+
+ /**
+ * Belongs to relations
+ */
+ protected $_belongsTo;
+
+ /**
+ * All the relationships by model
+ */
+ protected $_belongsToSingle;
+
+ /**
+ * Has many-Through relations
+ */
+ protected $_hasManyToMany;
+
+ /**
+ * Has many-Through relations by model
+ */
+ protected $_hasManyToManySingle;
+
+ /**
+ * Mark initialized models
+ */
+ protected $_initialized;
+
+
+ protected $_sources;
+
+
+ protected $_schemas;
+
+ /**
+ * Models' behaviors
+ */
+ protected $_behaviors;
+
+ /**
+ * Last model initialized
+ */
+ protected $_lastInitialized;
+
+ /**
+ * Last query created/executed
+ */
+ protected $_lastQuery;
+
+ /**
+ * Stores a list of reusable instances
+ */
+ protected $_reusable;
+
+
+ protected $_keepSnapshots;
+
+ /**
+ * Does the model use dynamic update, instead of updating all rows?
+ */
+ protected $_dynamicUpdate;
+
+
+ protected $_namespaceAliases;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a global events manager
+ *
+ * @param mixed $eventsManager
+ * @return Manager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return bool|\Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Initializes a model in the model manager
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function initialize(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get last initialized model
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Loads a model throwing an exception if it doesn't exist
+ *
+ * @param string $modelName
+ * @param bool $newInstance
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function load($modelName, $newInstance = false) {}
+
+ /**
+ * Sets the mapped source for a model
+ *
+ * @param mixed $model
+ * @param string $source
+ */
+ public function setModelSource(\Phalcon\Mvc\ModelInterface $model, $source) {}
+
+ /**
+ * Returns the mapped source for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSource(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets the mapped schema for a model
+ *
+ * @param mixed $model
+ * @param string $schema
+ */
+ public function setModelSchema(\Phalcon\Mvc\ModelInterface $model, $schema) {}
+
+ /**
+ * Returns the mapped schema for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSchema(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets both write and read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets write connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setWriteConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setReadConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Returns the connection to read data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to write data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to read or write data related to a model depending on the connection services.
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ protected function _getConnection(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Returns the connection service name used to read data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getReadConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to write data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getWriteConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to read or write data related to a model depending on the connection services
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return string
+ */
+ public function _getConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ */
+ public function missingMethod(\Phalcon\Mvc\ModelInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if a model must keep snapshots
+ *
+ * @param mixed $model
+ * @param bool $keepSnapshots
+ */
+ public function keepSnapshots(\Phalcon\Mvc\ModelInterface $model, $keepSnapshots) {}
+
+ /**
+ * Checks if a model is keeping snapshots for the queried records
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isKeepingSnapshots(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * @param mixed $model
+ * @param bool $dynamicUpdate
+ */
+ public function useDynamicUpdate(\Phalcon\Mvc\ModelInterface $model, $dynamicUpdate) {}
+
+ /**
+ * Checks if a model is using dynamic update instead of all-field update
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingDynamicUpdate(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasOne(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse many to one between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addBelongsTo(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasMany(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a relation n-m between two models
+ *
+ * @param string fields
+ * @param string intermediateModel
+ * @param string intermediateFields
+ * @param string intermediateReferencedFields
+ * @param string referencedModel
+ * @param string referencedFields
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param array $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasManyToMany(\Phalcon\Mvc\ModelInterface $model, $fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Checks whether a model has a belongsTo relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsBelongsTo($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasMany($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasOne relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasOne($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasManyToMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasManyToMany($modelName, $modelRelation) {}
+
+ /**
+ * Returns a relation by its alias
+ *
+ * @param string $modelName
+ * @param string $alias
+ * @return bool|\Phalcon\Mvc\Model\Relation
+ */
+ public function getRelationByAlias($modelName, $alias) {}
+
+ /**
+ * Merge two arrays of find parameters
+ *
+ * @param mixed $findParamsOne
+ * @param mixed $findParamsTwo
+ * @return array
+ */
+ protected final function _mergeFindParameters($findParamsOne, $findParamsTwo) {}
+
+ /**
+ * Helper method to query records based on a relation definition
+ *
+ * @param mixed $relation
+ * @param string $method
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return \Phalcon\Mvc\Model\Resultset\Simple|\Phalcon\Mvc\Model\Resultset\Simple|false
+ */
+ public function getRelationRecords(\Phalcon\Mvc\Model\RelationInterface $relation, $method, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Returns a reusable object from the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ */
+ public function getReusableRecords($modelName, $key) {}
+
+ /**
+ * Stores a reusable record in the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ * @param mixed $records
+ */
+ public function setReusableRecords($modelName, $key, $records) {}
+
+ /**
+ * Clears the internal reusable list
+ */
+ public function clearReusableObjects() {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getBelongsToRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets hasMany related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getHasManyRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getHasOneRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets all the belongsTo relations defined in a model
+ *
+ * $relations = $modelsManager->getBelongsTo(new Robots());
+ *
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getBelongsTo(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getHasOne(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasManyToMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasManyToMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasOneAndHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Query all the relationships defined on a model
+ *
+ * @param string $modelName
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelations($modelName) {}
+
+ /**
+ * Query the first relationship defined between two models
+ *
+ * @param string $first
+ * @param string $second
+ * @return bool|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelationsBetween($first, $second) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query without execute it
+ *
+ * @param string $phql
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function createQuery($phql) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query and execute it
+ *
+ * @param string $phql
+ * @param mixed $placeholders
+ * @param mixed $types
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function executeQuery($phql, $placeholders = null, $types = null) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query\Builder
+ *
+ * @param mixed $params
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function createBuilder($params = null) {}
+
+ /**
+ * Returns the lastest query created or executed in the models manager
+ *
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function getLastQuery() {}
+
+ /**
+ * Registers shorter aliases for namespaces in PHQL statements
+ *
+ * @param string $alias
+ * @param string $namespaceName
+ */
+ public function registerNamespaceAlias($alias, $namespaceName) {}
+
+ /**
+ * Returns a real namespace from its alias
+ *
+ * @param string $alias
+ * @return string
+ */
+ public function getNamespaceAlias($alias) {}
+
+ /**
+ * Returns all the registered namespace aliases
+ *
+ * @return array
+ */
+ public function getNamespaceAliases() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/ManagerInterface.php b/ide/2.0.5/Phalcon/mvc/model/ManagerInterface.php
new file mode 100644
index 000000000..3ef43fb12
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/ManagerInterface.php
@@ -0,0 +1,366 @@
+
+ * use Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if (this->name == 'Peter') {
+ * text = "A robot cannot be named Peter";
+ * field = "name";
+ * type = "InvalidValue";
+ * message = new Message(text, field, type);
+ * this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ */
+class Message implements \Phalcon\Mvc\Model\MessageInterface
+{
+
+ protected $_type;
+
+
+ protected $_message;
+
+
+ protected $_field;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Message constructor
+ *
+ * @param string $message
+ * @param string|array $field
+ * @param string $type
+ * @param \Phalcon\Mvc\ModelInterface $model
+ */
+ public function __construct($message, $field = null, $type = null, $model = null) {}
+
+ /**
+ * Sets message type
+ *
+ * @param string $type
+ * @return Message
+ */
+ public function setType($type) {}
+
+ /**
+ * Returns message type
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Sets verbose message
+ *
+ * @param string $message
+ * @return Message
+ */
+ public function setMessage($message) {}
+
+ /**
+ * Returns verbose message
+ *
+ * @return string
+ */
+ public function getMessage() {}
+
+ /**
+ * Sets field name related to message
+ *
+ * @param mixed $field
+ * @return Message
+ */
+ public function setField($field) {}
+
+ /**
+ * Returns field name related to message
+ */
+ public function getField() {}
+
+ /**
+ * Set the model who generates the message
+ *
+ * @param mixed $model
+ * @return Message
+ */
+ public function setModel(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the model that produced the message
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Magic __toString method returns verbose message
+ *
+ * @return string
+ */
+ public function __toString() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable exporting
+ *
+ * @param array $message
+ * @return Message
+ */
+ public static function __set_state($message) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/MessageInterface.php b/ide/2.0.5/Phalcon/mvc/model/MessageInterface.php
new file mode 100644
index 000000000..e192339b2
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/MessageInterface.php
@@ -0,0 +1,78 @@
+Because Phalcon\Mvc\Model requires meta-data like field names, data types, primary keys, etc.
+ * this component collect them and store for further querying by Phalcon\Mvc\Model.
+ * Phalcon\Mvc\Model\MetaData can also use adapters to store temporarily or permanently the meta-data.
+ * A standard Phalcon\Mvc\Model\MetaData can be used to query model attributes:
+ *
+ * $metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
+ * $attributes = $metaData->getAttributes(new Robots());
+ * print_r($attributes);
+ *
+ */
+abstract class MetaData implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const MODELS_ATTRIBUTES = 0;
+
+
+ const MODELS_PRIMARY_KEY = 1;
+
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+
+ const MODELS_NOT_NULL = 3;
+
+
+ const MODELS_DATA_TYPES = 4;
+
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+
+ const MODELS_DATE_AT = 6;
+
+
+ const MODELS_DATE_IN = 7;
+
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+
+ const MODELS_EMPTY_STRING_VALUES = 13;
+
+
+ const MODELS_COLUMN_MAP = 0;
+
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_strategy;
+
+
+ protected $_metaData;
+
+
+ protected $_columnMap;
+
+
+ /**
+ * Initialize the metadata for certain table
+ *
+ * @param mixed $model
+ * @param mixed $key
+ * @param mixed $table
+ * @param mixed $schema
+ */
+ protected final function _initialize(\Phalcon\Mvc\ModelInterface $model, $key, $table, $schema) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set the meta-data extraction strategy
+ *
+ * @param mixed $strategy
+ */
+ public function setStrategy(\Phalcon\Mvc\Model\MetaData\StrategyInterface $strategy) {}
+
+ /**
+ * Return the strategy to obtain the meta-data
+ *
+ * @return \Phalcon\Mvc\Model\MetaData\StrategyInterface
+ */
+ public function getStrategy() {}
+
+ /**
+ * Reads the complete meta-data for certain model
+ *
+ * print_r($metaData->readMetaData(new Robots());
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readMetaData(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads meta-data for certain model
+ *
+ * print_r($metaData->readMetaDataIndex(new Robots(), 0);
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Writes meta-data for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ * @param mixed $data
+ */
+ public final function writeMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index, $data) {}
+
+ /**
+ * Reads the ordered/reversed column map for certain model
+ *
+ * print_r($metaData->readColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads column-map information for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->readColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readColumnMapIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Returns table attributes names (fields)
+ *
+ * print_r($metaData->getAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are part of the primary key
+ *
+ * print_r($metaData->getPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are not part of the primary key
+ *
+ * print_r($metaData->getNonPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNonPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of not null attributes
+ *
+ * print_r($metaData->getNotNullAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNotNullAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their data types
+ *
+ * print_r($metaData->getDataTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes which types are numerical
+ *
+ * print_r($metaData->getDataTypesNumeric(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypesNumeric(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the name of identity field (if one is present)
+ *
+ * print_r($metaData->getIdentityField(new Robots()));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @return string
+ */
+ public function getIdentityField(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their bind data types
+ *
+ * print_r($metaData->getBindTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getBindTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the INSERT SQL generation
+ *
+ * print_r($metaData->getAutomaticCreateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the UPDATE SQL generation
+ *
+ * print_r($metaData->getAutomaticUpdateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Set the attributes that must be ignored from the INSERT SQL generation
+ *
+ * $metaData->setAutomaticCreateAttributes(new Robots(), array('created_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that must be ignored from the UPDATE SQL generation
+ *
+ * $metaData->setAutomaticUpdateAttributes(new Robots(), array('modified_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that allow empty string values
+ *
+ * $metaData->setEmptyStringAttributes(new Robots(), array('name' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Returns attributes allow empty strings
+ *
+ * print_r($metaData->getEmptyStringAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes (which have default values) and their default values
+ *
+ * print_r($metaData->getDefaultValues(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDefaultValues(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the column map if any
+ *
+ * print_r($metaData->getColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the reverse column map if any
+ *
+ * print_r($metaData->getReverseColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getReverseColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check if a model has certain attribute
+ *
+ * var_dump($metaData->hasAttribute(new Robots(), 'name'));
+ *
+ *
+ * @param mixed $model
+ * @param string $attribute
+ * @return bool
+ */
+ public function hasAttribute(\Phalcon\Mvc\ModelInterface $model, $attribute) {}
+
+ /**
+ * Checks if the internal meta-data container is empty
+ *
+ * var_dump($metaData->isEmpty());
+ *
+ *
+ * @return bool
+ */
+ public function isEmpty() {}
+
+ /**
+ * Resets internal meta-data in order to regenerate it
+ *
+ * $metaData->reset();
+ *
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/MetaDataInterface.php b/ide/2.0.5/Phalcon/mvc/model/MetaDataInterface.php
new file mode 100644
index 000000000..930c326a7
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/MetaDataInterface.php
@@ -0,0 +1,241 @@
+
+ * $phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
+ * WHERE b.name = :name: ORDER BY c.name";
+ * $result = manager->executeQuery($phql, array(
+ * "name": "Lamborghini"
+ * ));
+ * foreach ($result as $row) {
+ * echo "Name: ", $row->cars->name, "\n";
+ * echo "Price: ", $row->cars->price, "\n";
+ * echo "Taxes: ", $row->taxes, "\n";
+ * }
+ *
+ */
+class Query implements \Phalcon\Mvc\Model\QueryInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ const TYPE_SELECT = 309;
+
+
+ const TYPE_INSERT = 306;
+
+
+ const TYPE_UPDATE = 300;
+
+
+ const TYPE_DELETE = 303;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_manager;
+
+
+ protected $_metaData;
+
+
+ protected $_type;
+
+
+ protected $_phql;
+
+
+ protected $_ast;
+
+
+ protected $_intermediate;
+
+
+ protected $_models;
+
+
+ protected $_sqlAliases;
+
+
+ protected $_sqlAliasesModels;
+
+
+ protected $_sqlModelsAliases;
+
+
+ protected $_sqlAliasesModelsInstances;
+
+
+ protected $_sqlColumnAliases;
+
+
+ protected $_modelsInstances;
+
+
+ protected $_cache;
+
+
+ protected $_cacheOptions;
+
+
+ protected $_uniqueRow;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ static protected $_irPhqlCache;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query constructor
+ *
+ * @param string $phql
+ * @param \Phalcon\DiInterface $dependencyInjector
+ */
+ public function __construct($phql = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Tells to the query if only the first row in the resultset must be returned
+ *
+ * @param bool $uniqueRow
+ * @return Query
+ */
+ public function setUniqueRow($uniqueRow) {}
+
+ /**
+ * Check if the query is programmed to get only the first row in the resultset
+ *
+ * @return bool
+ */
+ public function getUniqueRow() {}
+
+ /**
+ * Replaces the model's name to its source name in a qualifed-name expression
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getQualified($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $argument
+ * @return array
+ */
+ protected final function _getCallArgument($argument) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getCaseExpression($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getFunctionCall($expr) {}
+
+ /**
+ * Resolves an expression from its intermediate code into a string
+ *
+ * @param array $expr
+ * @param boolean $quoting
+ * @return string
+ */
+ protected final function _getExpression($expr, $quoting = true) {}
+
+ /**
+ * Resolves a column from its intermediate representation into an array used to determine
+ * if the resultset produced is simple or complex
+ *
+ * @param array $column
+ * @return array
+ */
+ protected final function _getSelectColumn($column) {}
+
+ /**
+ * Resolves a table in a SELECT statement checking if the model exists
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $qualifiedName
+ * @return string
+ */
+ protected final function _getTable(\Phalcon\Mvc\Model\ManagerInterface $manager, $qualifiedName) {}
+
+ /**
+ * Resolves a JOIN clause checking if the associated models exist
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $join
+ * @return array
+ */
+ protected final function _getJoin(\Phalcon\Mvc\Model\ManagerInterface $manager, $join) {}
+
+ /**
+ * Resolves a JOIN type
+ *
+ * @param array $join
+ * @return string
+ */
+ protected final function _getJoinType($join) {}
+
+ /**
+ * Resolves joins involving has-one/belongs-to/has-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getSingleJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Resolves joins involving many-to-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getMultiJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Processes the JOINs in the query returning an internal representation for the database dialect
+ *
+ * @param array $select
+ * @return array
+ */
+ protected final function _getJoins($select) {}
+
+ /**
+ * Returns a processed order clause for a SELECT statement
+ *
+ * @param mixed $order
+ * @param array|string $$order
+ * @return array
+ */
+ protected final function _getOrderClause($order) {}
+
+ /**
+ * Returns a processed group clause for a SELECT statement
+ *
+ * @param array $group
+ * @return array
+ */
+ protected final function _getGroupClause($group) {}
+
+ /**
+ * Returns a processed limit clause for a SELECT statement
+ *
+ * @param array $limitClause
+ * @return array
+ */
+ protected final function _getLimitClause($limitClause) {}
+
+ /**
+ * Analyzes a SELECT intermediate code and produces an array to be executed later
+ *
+ * @param mixed $ast
+ * @param mixed $merge
+ * @return array
+ */
+ protected final function _prepareSelect($ast = null, $merge = null) {}
+
+ /**
+ * Analyzes an INSERT intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareInsert() {}
+
+ /**
+ * Analyzes an UPDATE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareUpdate() {}
+
+ /**
+ * Analyzes a DELETE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareDelete() {}
+
+ /**
+ * Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another
+ * intermediate representation that could be executed by Phalcon\Mvc\Model\Query
+ *
+ * @return array
+ */
+ public function parse() {}
+
+ /**
+ * Returns the current cache backend instance
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Executes the SELECT intermediate representation producing a Phalcon\Mvc\Model\Resultset
+ *
+ * @param mixed $intermediate
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @param bool $simulate
+ * @return array|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _executeSelect($intermediate, $bindParams, $bindTypes, $simulate = false) {}
+
+ /**
+ * Executes the INSERT intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeInsert($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the UPDATE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeUpdate($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the DELETE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeDelete($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Query the records on which the UPDATE/DELETE operation well be done
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _getRelatedRecords(\Phalcon\Mvc\ModelInterface $model, $intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes a parsed PHQL statement
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return mixed
+ */
+ public function execute($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Executes the query returning the first result
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return Ṕhalcon\Mvc\ModelInterface
+ */
+ public function getSingleResult($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sets the type of PHQL statement to be executed
+ *
+ * @param int $type
+ * @return Query
+ */
+ public function setType($type) {}
+
+ /**
+ * Gets the type of PHQL statement executed
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindParams
+ * @param bool $merge
+ * @return Query
+ */
+ public function setBindParams($bindParams, $merge = false) {}
+
+ /**
+ * Returns default bind params
+ *
+ * @return array
+ */
+ public function getBindParams() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindTypes
+ * @param bool $merge
+ * @return Query
+ */
+ public function setBindTypes($bindTypes, $merge = false) {}
+
+ /**
+ * Returns default bind types
+ *
+ * @return array
+ */
+ public function getBindTypes() {}
+
+ /**
+ * Allows to set the IR to be executed
+ *
+ * @param array $intermediate
+ * @return Query
+ */
+ public function setIntermediate($intermediate) {}
+
+ /**
+ * Returns the intermediate representation of the PHQL statement
+ *
+ * @return array
+ */
+ public function getIntermediate() {}
+
+ /**
+ * Sets the cache parameters of the query
+ *
+ * @param mixed $cacheOptions
+ * @return Query
+ */
+ public function cache($cacheOptions) {}
+
+ /**
+ * Returns the current cache options
+ *
+ * @param array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
+ *
+ * @return array
+ */
+ public function getSql() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/QueryInterface.php b/ide/2.0.5/Phalcon/mvc/model/QueryInterface.php
new file mode 100644
index 000000000..058d68f18
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/QueryInterface.php
@@ -0,0 +1,59 @@
+
+ * //Using a standard foreach
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ * //Using a while
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * $robots->rewind();
+ * while ($robots->valid()) {
+ * $robot = $robots->current();
+ * echo $robot->name, "\n";
+ * $robots->next();
+ * }
+ *
+ */
+abstract class Resultset implements \Phalcon\Mvc\Model\ResultsetInterface, \Iterator, \SeekableIterator, \Countable, \ArrayAccess, \Serializable
+{
+
+ const TYPE_RESULT_FULL = 0;
+
+
+ const TYPE_RESULT_PARTIAL = 1;
+
+
+ const HYDRATE_RECORDS = 0;
+
+
+ const HYDRATE_OBJECTS = 2;
+
+
+ const HYDRATE_ARRAYS = 1;
+
+ /**
+ * Phalcon\Db\ResultInterface or false for empty resultset
+ */
+ protected $_result = false;
+
+
+ protected $_cache;
+
+
+ protected $_isFresh = true;
+
+
+ protected $_pointer = 0;
+
+
+ protected $_count;
+
+
+ protected $_activeRow = null;
+
+
+ protected $_rows = null;
+
+
+ protected $_row = null;
+
+
+ protected $_errorMessages;
+
+
+ protected $_hydrateMode = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Resultset constructor
+ *
+ * @param \Phalcon\Db\ResultInterface|false $result
+ * @param \Phalcon\Cache\BackendInterface $cache
+ * @param array $columnTypes
+ */
+ public function __construct($result, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Moves cursor to next row in the resultset
+ */
+ public function next() {}
+
+ /**
+ * Check whether internal resource has rows to fetch
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Gets pointer number of active row in the resultset
+ *
+ * @return int|null
+ */
+ public function key() {}
+
+ /**
+ * Rewinds resultset to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Changes internal pointer to a specific position in the resultset
+ * Set new position if required and set this->_row
+ *
+ * @param int $position
+ */
+ public final function seek($position) {}
+
+ /**
+ * Counts how many rows are in the resultset
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Checks whether offset exists in the resultset
+ *
+ * @param int $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets row in a specific position of the resultset
+ *
+ * @param int $index
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Returns the internal type of data retrieval that the resultset is using
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Get first row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getFirst() {}
+
+ /**
+ * Get last row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getLast() {}
+
+ /**
+ * Set if the resultset is fresh or an old one cached
+ *
+ * @param bool $isFresh
+ * @return Resultset
+ */
+ public function setIsFresh($isFresh) {}
+
+ /**
+ * Tell if the resultset if fresh or an old one cached
+ *
+ * @return bool
+ */
+ public function isFresh() {}
+
+ /**
+ * Sets the hydration mode in the resultset
+ *
+ * @param int $hydrateMode
+ * @return Resultset
+ */
+ public function setHydrateMode($hydrateMode) {}
+
+ /**
+ * Returns the current hydration mode
+ *
+ * @return int
+ */
+ public function getHydrateMode() {}
+
+ /**
+ * Returns the associated cache for the resultset
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Returns the error messages produced by a batch operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Updates every record in the resultset
+ *
+ * @param array $data
+ * @param Closure $conditionCallback
+ * @return boolean
+ */
+ public function update($data, \Closure $conditionCallback = null) {}
+
+ /**
+ * Deletes every record in the resultset
+ *
+ * @param mixed $conditionCallback
+ * @return bool
+ */
+ public function delete(\Closure $conditionCallback = null) {}
+
+ /**
+ * Filters a resultset returning only those the developer requires
+ *
+ * $filtered = $robots->filter(function($robot){
+ * if ($robot->id < 3) {
+ * return $robot;
+ * }
+ * });
+ *
+ *
+ * @param callback $filter
+ * @return \Phalcon\Mvc\Model[]
+ */
+ public function filter($filter) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/ResultsetInterface.php b/ide/2.0.5/Phalcon/mvc/model/ResultsetInterface.php
new file mode 100644
index 000000000..58903e36e
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/ResultsetInterface.php
@@ -0,0 +1,62 @@
+x or array[x].
+ */
+class Row implements \Phalcon\Mvc\EntityInterface, \Phalcon\Mvc\Model\ResultInterface, \ArrayAccess
+{
+
+ /**
+ * Set the current object's state
+ *
+ * @param int $dirtyState
+ * @return bool
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Checks whether offset exists in the row
+ *
+ * @param mixed $index
+ * @param string|int $$index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets a record in a specific position of the row
+ *
+ * @param string|int $index
+ * @return string|Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/Transaction.php b/ide/2.0.5/Phalcon/mvc/model/Transaction.php
new file mode 100644
index 000000000..cfc88900d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/Transaction.php
@@ -0,0 +1,146 @@
+
+ * try {
+ * $manager = new \Phalcon\Mvc\Model\Transaction\Manager();
+ * $transaction = $manager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch(Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Transaction implements \Phalcon\Mvc\Model\TransactionInterface
+{
+
+ protected $_connection;
+
+
+ protected $_activeTransaction = false;
+
+
+ protected $_isNewTransaction = true;
+
+
+ protected $_rollbackOnAbort = false;
+
+
+ protected $_manager;
+
+
+ protected $_messages;
+
+
+ protected $_rollbackRecord;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param boolean $autoBegin
+ * @param string $service
+ * @param \Phalcon\DiInterface $$ependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector, $autoBegin = false, $service = null) {}
+
+ /**
+ * Sets transaction manager related to the transaction
+ *
+ * @param mixed $manager
+ */
+ public function setTransactionManager(\Phalcon\Mvc\Model\Transaction\ManagerInterface $manager) {}
+
+ /**
+ * Starts the transaction
+ *
+ * @return bool
+ */
+ public function begin() {}
+
+ /**
+ * Commits the transaction
+ *
+ * @return bool
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks the transaction
+ *
+ * @param string $rollbackMessage
+ * @param \Phalcon\Mvc\ModelInterface $rollbackRecord
+ * @return boolean
+ */
+ public function rollback($rollbackMessage = null, $rollbackRecord = null) {}
+
+ /**
+ * Returns the connection related to transaction
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection() {}
+
+ /**
+ * Sets if is a reused transaction or new once
+ *
+ * @param bool $isNew
+ */
+ public function setIsNewTransaction($isNew) {}
+
+ /**
+ * Sets flag to rollback on abort the HTTP connection
+ *
+ * @param bool $rollbackOnAbort
+ */
+ public function setRollbackOnAbort($rollbackOnAbort) {}
+
+ /**
+ * Checks whether transaction is managed by a transaction manager
+ *
+ * @return bool
+ */
+ public function isManaged() {}
+
+ /**
+ * Returns validations messages from last save try
+ *
+ * @return array
+ */
+ public function getMessages() {}
+
+ /**
+ * Checks whether internal connection is under an active transaction
+ *
+ * @return bool
+ */
+ public function isValid() {}
+
+ /**
+ * Sets object which generates rollback action
+ *
+ * @param mixed $record
+ */
+ public function setRollbackedRecord(\Phalcon\Mvc\ModelInterface $record) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/TransactionInterface.php b/ide/2.0.5/Phalcon/mvc/model/TransactionInterface.php
new file mode 100644
index 000000000..88a500734
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/TransactionInterface.php
@@ -0,0 +1,91 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Apc(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Apc extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from APC
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/metadata/Files.php b/ide/2.0.5/Phalcon/mvc/model/metadata/Files.php
new file mode 100644
index 000000000..86b59be2c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/metadata/Files.php
@@ -0,0 +1,43 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Files(array(
+ * 'metaDataDir' => 'app/cache/metadata/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_metaDataDir = "./";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from files
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to files
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/metadata/Libmemcached.php b/ide/2.0.5/Phalcon/mvc/model/metadata/Libmemcached.php
new file mode 100644
index 000000000..aa7c47fd2
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/metadata/Libmemcached.php
@@ -0,0 +1,60 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Libmemcached(array(
+ * 'servers' => array(
+ * array('host' => 'localhost', 'port' => 11211, 'weight' => 1),
+ * ),
+ * 'client' => array(
+ * Memcached::OPT_HASH => Memcached::HASH_MD5,
+ * Memcached::OPT_PREFIX_KEY => 'prefix.',
+ * ),
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ *
+ */
+class Libmemcached extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_ttl = 172800;
+
+
+ protected $_memcache = null;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Libmemcached constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from Memcache
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to Memcache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+ /**
+ * Flush Memcache data and resets internal meta-data in order to regenerate it
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/metadata/Memcache.php b/ide/2.0.5/Phalcon/mvc/model/metadata/Memcache.php
new file mode 100644
index 000000000..73637fade
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/metadata/Memcache.php
@@ -0,0 +1,56 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Memcache(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400,
+ * 'host' => 'localhost',
+ * 'port' => 11211,
+ * 'persistent' => false
+ * ));
+ *
+ */
+class Memcache extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_ttl = 172800;
+
+
+ protected $_memcache = null;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Memcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from Memcache
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to Memcache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+ /**
+ * Flush Memcache data and resets internal meta-data in order to regenerate it
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/metadata/Memory.php b/ide/2.0.5/Phalcon/mvc/model/metadata/Memory.php
new file mode 100644
index 000000000..c389c473f
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/metadata/Memory.php
@@ -0,0 +1,35 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Session(array(
+ * 'prefix' => 'my-app-id'
+ * ));
+ *
+ */
+class Session extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Session constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from $_SESSION
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to $_SESSION
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/metadata/StrategyInterface.php b/ide/2.0.5/Phalcon/mvc/model/metadata/StrategyInterface.php
new file mode 100644
index 000000000..b7874be24
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/metadata/StrategyInterface.php
@@ -0,0 +1,28 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Xcache(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Xcache extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Xcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from XCache
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to XCache
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/metadata/strategy/Annotations.php b/ide/2.0.5/Phalcon/mvc/model/metadata/strategy/Annotations.php
new file mode 100644
index 000000000..f1b7b11fa
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/metadata/strategy/Annotations.php
@@ -0,0 +1,27 @@
+
+ * $params = array(
+ * 'models' => array('Users'),
+ * 'columns' => array('id', 'name', 'status'),
+ * 'conditions' => array(
+ * array(
+ * "created > :min: AND created < :max:",
+ * array("min" => '2013-01-01', 'max' => '2014-01-01'),
+ * array("min" => PDO::PARAM_STR, 'max' => PDO::PARAM_STR),
+ * ),
+ * ),
+ * // or 'conditions' => "created > '2013-01-01' AND created < '2014-01-01'",
+ * 'group' => array('id', 'name'),
+ * 'having' => "name = 'Kamil'",
+ * 'order' => array('name', 'id'),
+ * 'limit' => 20,
+ * 'offset' => 20,
+ * // or 'limit' => array(20, 20),
+ * );
+ * $queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);
+ *
+ */
+class Builder implements \Phalcon\Mvc\Model\Query\BuilderInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_columns;
+
+
+ protected $_models;
+
+
+ protected $_joins;
+
+
+ protected $_with;
+
+
+ protected $_conditions;
+
+
+ protected $_group;
+
+
+ protected $_having;
+
+
+ protected $_order;
+
+
+ protected $_limit;
+
+
+ protected $_offset;
+
+
+ protected $_forUpdate;
+
+
+ protected $_sharedLock;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_distinct;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Builder constructor
+ *
+ * @param mixed $params
+ * @param mixed $dependencyInjector
+ */
+ public function __construct($params = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ * @return Builder
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param bool|null $distinct
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function distinct($distinct) {}
+
+ /**
+ * Returns SELECT DISTINCT / SELECT ALL flag
+ *
+ * @return bool
+ */
+ public function getDistinct() {}
+
+ /**
+ * Sets the columns to be queried
+ *
+ * $builder->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function columns($columns) {}
+
+ /**
+ * Return the columns to be queried
+ *
+ * @return string|array
+ */
+ public function getColumns() {}
+
+ /**
+ * Sets the models who makes part of the query
+ *
+ * $builder->from('Robots');
+ * $builder->from(array('Robots', 'RobotsParts'));
+ *
+ *
+ * @param string|array $models
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function from($models) {}
+
+ /**
+ * Add a model to take part of the query
+ *
+ * $builder->addFrom('Robots', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function addFrom($model, $alias = null) {}
+
+ /**
+ * Return the models who makes part of the query
+ *
+ * @return string|array
+ */
+ public function getFrom() {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->join('Robots');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'INNER');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->innerJoin('Robots');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $builder->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $builder->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the query conditions
+ *
+ * $builder->where(100);
+ * $builder->where('name = "Peter"');
+ * $builder->where('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param mixed $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a AND operator
+ *
+ * $builder->andWhere('name = "Peter"');
+ * $builder->andWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a OR operator
+ *
+ * $builder->orWhere('name = "Peter"');
+ * $builder->orWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $builder->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Builder
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $builder->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Builder
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $builder->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $builder->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Return the conditions for the query
+ *
+ * @return string|array
+ */
+ public function getWhere() {}
+
+ /**
+ * Sets a ORDER BY condition clause
+ *
+ * $builder->orderBy('Robots.name');
+ * $builder->orderBy(array('1', 'Robots.name'));
+ *
+ *
+ * @param string|array $orderBy
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orderBy($orderBy) {}
+
+ /**
+ * Returns the set ORDER BY clause
+ *
+ * @return string|array
+ */
+ public function getOrderBy() {}
+
+ /**
+ * Sets a HAVING condition clause. You need to escape PHQL reserved words using [ and ] delimiters
+ *
+ * $builder->having('SUM(Robots.price) > 0');
+ *
+ *
+ * @param string $having
+ * @return Builder
+ */
+ public function having($having) {}
+
+ /**
+ * Sets a FOR UPDATE clause
+ *
+ * $builder->forUpdate(true);
+ *
+ *
+ * @param bool $forUpdate
+ * @return Builder
+ */
+ public function forUpdate($forUpdate) {}
+
+ /**
+ * Return the current having clause
+ *
+ * @return string|array
+ */
+ public function getHaving() {}
+
+ /**
+ * Sets a LIMIT clause, optionally a offset clause
+ *
+ * $builder->limit(100);
+ * $builder->limit(100, 20);
+ *
+ *
+ * @param int $limit
+ * @param int $offset
+ * @return Builder
+ */
+ public function limit($limit = null, $offset = null) {}
+
+ /**
+ * Returns the current LIMIT clause
+ *
+ * @return string|array
+ */
+ public function getLimit() {}
+
+ /**
+ * Sets an OFFSET clause
+ *
+ * $builder->offset(30);
+ *
+ *
+ * @param int $offset
+ * @return Builder
+ */
+ public function offset($offset) {}
+
+ /**
+ * Returns the current OFFSET clause
+ *
+ * @return string|array
+ */
+ public function getOffset() {}
+
+ /**
+ * Sets a GROUP BY clause
+ *
+ * $builder->groupBy(array('Robots.name'));
+ *
+ *
+ * @param string|array $group
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function groupBy($group) {}
+
+ /**
+ * Returns the GROUP BY clause
+ *
+ * @return string
+ */
+ public function getGroupBy() {}
+
+ /**
+ * Returns a PHQL statement built based on the builder parameters
+ *
+ * @return string
+ */
+ public final function getPhql() {}
+
+ /**
+ * Returns the query built
+ *
+ * @return \Phalcon\Mvc\Model\Query
+ */
+ public function getQuery() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/query/BuilderInterface.php b/ide/2.0.5/Phalcon/mvc/model/query/BuilderInterface.php
new file mode 100644
index 000000000..9e8b04895
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/query/BuilderInterface.php
@@ -0,0 +1,249 @@
+
+ * $intermediate = Phalcon\Mvc\Model\Query\Lang::parsePHQL("SELECT r.* FROM Robots r LIMIT 10");
+ *
+ */
+abstract class Lang
+{
+
+ /**
+ * Parses a PHQL statement returning an intermediate representation (IR)
+ *
+ * @param string $phql
+ * @return string
+ */
+ public static function parsePHQL($phql) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/query/Status.php b/ide/2.0.5/Phalcon/mvc/model/query/Status.php
new file mode 100644
index 000000000..44bd6423d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/query/Status.php
@@ -0,0 +1,63 @@
+
+ * $phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";
+ * $status = $app->modelsManager->executeQuery($phql, array(
+ * 'id' => 100,
+ * 'name' => 'Astroy Boy',
+ * 'type' => 'mechanical',
+ * 'year' => 1959
+ * ));
+ * \//Check if the update was successful
+ * if ($status->success() == true) {
+ * echo 'OK';
+ * }
+ *
+ */
+class Status implements \Phalcon\Mvc\Model\Query\StatusInterface
+{
+
+ protected $_success;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Status
+ *
+ * @param bool $success
+ * @param mixed $model
+ */
+ public function __construct($success, \Phalcon\Mvc\ModelInterface $model = null) {}
+
+ /**
+ * Returns the model that executed the action
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Returns the messages produced because of a failed operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Allows to check if the executed operation was successful
+ *
+ * @return bool
+ */
+ public function success() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/query/StatusInterface.php b/ide/2.0.5/Phalcon/mvc/model/query/StatusInterface.php
new file mode 100644
index 000000000..9b1b58318
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/query/StatusInterface.php
@@ -0,0 +1,41 @@
+
+ * try {
+ * use Phalcon\Mvc\Model\Transaction\Manager as TransactionManager;
+ * $transactionManager = new TransactionManager();
+ * $transaction = $transactionManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if($robot->save()==false){
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if($robotPart->save()==false){
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch (Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\Transaction\ManagerInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized = false;
+
+
+ protected $_rollbackPendent = true;
+
+
+ protected $_number = 0;
+
+
+ protected $_service = "db";
+
+
+ protected $_transactions;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction\Manager constructor
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the database service used to run the isolated transactions
+ *
+ * @param string $service
+ * @return Manager
+ */
+ public function setDbService($service) {}
+
+ /**
+ * Returns the database service used to isolate the transaction
+ *
+ * @return string
+ */
+ public function getDbService() {}
+
+ /**
+ * Set if the transaction manager must register a shutdown function to clean up pendent transactions
+ *
+ * @param bool $rollbackPendent
+ * @return Manager
+ */
+ public function setRollbackPendent($rollbackPendent) {}
+
+ /**
+ * Check if the transaction manager is registering a shutdown function to clean up pendent transactions
+ *
+ * @return bool
+ */
+ public function getRollbackPendent() {}
+
+ /**
+ * Checks whether the manager has an active transaction
+ *
+ * @return bool
+ */
+ public function has() {}
+
+ /**
+ * Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
+ * This method registers a shutdown function to rollback active connections
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function get($autoBegin = true) {}
+
+ /**
+ * Create/Returns a new transaction or an existing one
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function getOrCreateTransaction($autoBegin = true) {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ */
+ public function rollbackPendent() {}
+
+ /**
+ * Commmits active transactions within the manager
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ * Collect will remove the transaction from the manager
+ *
+ * @param boolean $collect
+ */
+ public function rollback($collect = true) {}
+
+ /**
+ * Notifies the manager about a rollbacked transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyRollback(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Notifies the manager about a commited transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyCommit(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Removes transactions from the TransactionManager
+ *
+ * @param mixed $transaction
+ */
+ protected function _collectTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Remove all the transactions from the manager
+ */
+ public function collectTransactions() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/transaction/ManagerInterface.php b/ide/2.0.5/Phalcon/mvc/model/transaction/ManagerInterface.php
new file mode 100644
index 000000000..5fc97d481
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/transaction/ManagerInterface.php
@@ -0,0 +1,71 @@
+
+ * use Phalcon\Mvc\Model\Validator\Email as EmailValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new EmailValidator(array(
+ * 'field' => 'electronic_mail'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Email extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Email() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/Exclusionin.php b/ide/2.0.5/Phalcon/mvc/model/validator/Exclusionin.php
new file mode 100644
index 000000000..472e40659
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/Exclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionInValidator(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Exclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Exclusionin() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/Inclusionin.php b/ide/2.0.5/Phalcon/mvc/model/validator/Inclusionin.php
new file mode 100644
index 000000000..885a18695
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/Inclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\InclusionIn as InclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new InclusionInValidator(array(
+ * "field" => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Inclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Inclusionin() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/Ip.php b/ide/2.0.5/Phalcon/mvc/model/validator/Ip.php
new file mode 100644
index 000000000..d299c5d83
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/Ip.php
@@ -0,0 +1,62 @@
+
+ * use Phalcon\Mvc\Model\Validator\CardNumber;
+ * class Data extends Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * // Any pubic IP
+ * $this->validate(new IPv4(array(
+ * 'field' => 'server_ip',
+ * 'version' => IP::VERSION_4 | IP::VERSION_6, // v6 and v4. The same if not specified
+ * 'allowReserved' => false, // False if not specified. Ignored for v6
+ * 'allowPrivate' => false, // False if not specified
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * // Any public v4 address
+ * $this->validate(new IP(array(
+ * 'field' => 'ip_4',
+ * 'version' => IP::VERSION_4,
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * // Any v6 address
+ * $this->validate(new IP(array(
+ * 'field' => 'ip6',
+ * 'version' => IP::VERSION_6,
+ * 'allowPrivate' => true,
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Ip extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ const VERSION_4 = 1048576;
+
+
+ const VERSION_6 = 2097152;
+
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Ip() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/Numericality.php b/ide/2.0.5/Phalcon/mvc/model/validator/Numericality.php
new file mode 100644
index 000000000..3e8ee0c64
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/Numericality.php
@@ -0,0 +1,38 @@
+
+ * use Phalcon\Mvc\Model\Validator\Numericality as NumericalityValidator;
+ * class Products extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new NumericalityValidator(array(
+ * "field" => 'price'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Numericality extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Numericality() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/PresenceOf.php b/ide/2.0.5/Phalcon/mvc/model/validator/PresenceOf.php
new file mode 100644
index 000000000..97471fec4
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/PresenceOf.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\PresenceOf;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new PresenceOf(array(
+ * "field" => 'name',
+ * "message" => 'The name is required'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class PresenceOf extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_PresenceOf() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/Regex.php b/ide/2.0.5/Phalcon/mvc/model/validator/Regex.php
new file mode 100644
index 000000000..c89d1e5b1
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/Regex.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\Regex as RegexValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new RegexValidator(array(
+ * "field" => 'created_at',
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])/'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Regex extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Regex() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/StringLength.php b/ide/2.0.5/Phalcon/mvc/model/validator/StringLength.php
new file mode 100644
index 000000000..b1588c7b5
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/StringLength.php
@@ -0,0 +1,42 @@
+
+ * use Phalcon\Mvc\Model\Validator\StringLength as StringLengthValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new StringLengthValidator(array(
+ * "field" => 'name_last',
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class StringLength extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_StringLength() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/Uniqueness.php b/ide/2.0.5/Phalcon/mvc/model/validator/Uniqueness.php
new file mode 100644
index 000000000..5476d9bfe
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/Uniqueness.php
@@ -0,0 +1,40 @@
+
+ * use Phalcon\Mvc\Model;
+ * use Phalcon\Mvc\Model\Validator\Uniqueness;
+ * class Subscriptors extends Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new Uniqueness(array(
+ * "field" => 'email'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Uniqueness extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Uniqueness() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/model/validator/Url.php b/ide/2.0.5/Phalcon/mvc/model/validator/Url.php
new file mode 100644
index 000000000..9579116c2
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/model/validator/Url.php
@@ -0,0 +1,38 @@
+
+ * use Phalcon\Mvc\Model\Validator\Url as UrlValidator;
+ * class Posts extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new UrlValidator(array(
+ * 'field' => 'source_url'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Url extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Url() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/router/Annotations.php b/ide/2.0.5/Phalcon/mvc/router/Annotations.php
new file mode 100644
index 000000000..20343fb9d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/router/Annotations.php
@@ -0,0 +1,105 @@
+
+ * $di['router'] = function() {
+ * //Use the annotations router
+ * $router = new Annotations(false);
+ * //This will do the same as above but only if the handled uri starts with /robots
+ * $router->addResource('Robots', '/robots');
+ * return $router;
+ * };
+ *
+ */
+class Annotations extends \Phalcon\Mvc\Router
+{
+
+ protected $_handlers;
+
+
+ protected $_processed = false;
+
+
+ protected $_controllerSuffix = "Controller";
+
+
+ protected $_actionSuffix = "Action";
+
+
+ protected $_routePrefix;
+
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ *
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addResource($handler, $prefix = null) {}
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ * The class is located in a module
+ *
+ * @param string $module
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addModuleResource($module, $handler, $prefix = null) {}
+
+ /**
+ * Produce the routing parameters from the rewrite information
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Checks for annotations in the controller docblock
+ *
+ * @param string $handler
+ * @param mixed $annotation
+ */
+ public function processControllerAnnotation($handler, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Checks for annotations in the public methods of the controller
+ *
+ * @param string $module
+ * @param string $namespaceName
+ * @param string $controller
+ * @param string $action
+ * @param \Phalcon\Annotations\Annotation $annotation
+ */
+ public function processActionAnnotation($module, $namespaceName, $controller, $action, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Changes the controller class suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Changes the action method suffix
+ *
+ * @param string $actionSuffix
+ */
+ public function setActionSuffix($actionSuffix) {}
+
+ /**
+ * Return the registered resources
+ *
+ * @return array
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/router/Exception.php b/ide/2.0.5/Phalcon/mvc/router/Exception.php
new file mode 100644
index 000000000..e8a40f672
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/router/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+class Group implements \Phalcon\Mvc\Router\GroupInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_hostname;
+
+
+ protected $_paths;
+
+
+ protected $_routes;
+
+
+ protected $_beforeMatch;
+
+
+ /**
+ * Phalcon\Mvc\Router\Group constructor
+ *
+ * @param mixed $paths
+ */
+ public function __construct($paths = null) {}
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param mixed $paths
+ * @return GroupInterface
+ */
+ public function setPaths($paths) {}
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addGet($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPost($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPut($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPatch($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addDelete($pattern, $paths = null) {}
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addOptions($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addHead($pattern, $paths = null) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Adds a route applying the common attributes
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ protected function _addRoute($pattern, $paths = null, $httpMethods = null) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/router/GroupInterface.php b/ide/2.0.5/Phalcon/mvc/router/GroupInterface.php
new file mode 100644
index 000000000..bd9481889
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/router/GroupInterface.php
@@ -0,0 +1,186 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+interface GroupInterface
+{
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname);
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname();
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix);
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix();
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch);
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch();
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param array $paths
+ * @return \Phalcon\Mvc\Router\Group
+ */
+ public function setPaths($paths);
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths();
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes();
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null);
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null);
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear();
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/router/Route.php b/ide/2.0.5/Phalcon/mvc/router/Route.php
new file mode 100644
index 000000000..5cb392f08
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/router/Route.php
@@ -0,0 +1,243 @@
+
+ * $route->via('GET');
+ * $route->via(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function via($httpMethods) {}
+
+ /**
+ * Extracts parameters from a string
+ *
+ * @param string $pattern
+ * @return array|bool
+ */
+ public function extractNamedParams($pattern) {}
+
+ /**
+ * Reconfigure the route adding a new pattern and a set of paths
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ */
+ public function reConfigure($pattern, $paths = null) {}
+
+ /**
+ * Returns routePaths
+ *
+ * @param mixed $paths
+ * @return array
+ */
+ public static function getRoutePaths($paths = null) {}
+
+ /**
+ * Returns the route's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets the route's name
+ *
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $callback
+ * @return Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Sets a set of HTTP methods that constraint the matching of the route (alias of via)
+ *
+ * $route->setHttpMethods('GET');
+ * $route->setHttpMethods(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function setHttpMethods($httpMethods) {}
+
+ /**
+ * Returns the HTTP methods that constraint matching the route
+ *
+ * @return array|string
+ */
+ public function getHttpMethods() {}
+
+ /**
+ * Sets a hostname restriction to the route
+ *
+ * $route->setHostname('localhost');
+ *
+ *
+ * @param string $hostname
+ * @return Route
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction if any
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Sets the group associated with the route
+ *
+ * @param mixed $group
+ * @return Route
+ */
+ public function setGroup(GroupInterface $group) {}
+
+ /**
+ * Returns the group associated with the route
+ *
+ * @return null|GroupInterface
+ */
+ public function getGroup() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param mixed $converter
+ * @return Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/router/RouteInterface.php b/ide/2.0.5/Phalcon/mvc/router/RouteInterface.php
new file mode 100644
index 000000000..e49f3af1d
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/router/RouteInterface.php
@@ -0,0 +1,113 @@
+
+ * $view = new \Phalcon\Mvc\View\Simple();
+ * echo $view->render('templates/my-view', array('content' => $html));
+ * //or with filename with extension
+ * echo $view->render('templates/my-view.volt', array('content' => $html));
+ *
+ */
+class Simple extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewBaseInterface
+{
+
+ protected $_options;
+
+
+ protected $_viewsDir;
+
+
+ protected $_partialsDir;
+
+
+ protected $_viewParams;
+
+
+ protected $_engines = false;
+
+
+ protected $_registeredEngines;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_content;
+
+
+ protected $_cache = false;
+
+
+ protected $_cacheOptions;
+
+
+
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View\Simple constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Tries to render the view with every engine registered in the component
+ *
+ * @param string $path
+ * @param array $params
+ */
+ protected final function _internalRender($path, $params) {}
+
+ /**
+ * Renders a view
+ *
+ * @param string $path
+ * @param array $params
+ * @return string
+ */
+ public function render($path, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Sets the cache options
+ *
+ * @param array $options
+ * @return \Phalcon\Mvc\View\Simple
+ */
+ public function setCacheOptions($options) {}
+
+ /**
+ * Returns the cache options
+ *
+ * @return array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param mixed $options
+ * @return Simple
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param bool $merge
+ * @return Simple
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return Simple
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/mvc/view/engine/Php.php b/ide/2.0.5/Phalcon/mvc/view/engine/Php.php
new file mode 100644
index 000000000..d554be8de
--- /dev/null
+++ b/ide/2.0.5/Phalcon/mvc/view/engine/Php.php
@@ -0,0 +1,21 @@
+
+ * $compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();
+ * $compiler->compile('views/partials/header.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ */
+class Compiler implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_view;
+
+
+ protected $_options;
+
+
+ protected $_arrayHelpers;
+
+
+ protected $_level = 0;
+
+
+ protected $_foreachLevel = 0;
+
+
+ protected $_blockLevel = 0;
+
+
+ protected $_exprLevel = 0;
+
+
+ protected $_extended = false;
+
+
+ protected $_autoescape = false;
+
+
+ protected $_extendedBlocks;
+
+
+ protected $_currentBlock;
+
+
+ protected $_blocks;
+
+
+ protected $_forElsePointers;
+
+
+ protected $_loopPointers;
+
+
+ protected $_extensions;
+
+
+ protected $_functions;
+
+
+ protected $_filters;
+
+
+ protected $_macros;
+
+
+ protected $_prefix;
+
+
+ protected $_currentPath;
+
+
+ protected $_compiledTemplatePath;
+
+
+ /**
+ * Phalcon\Mvc\View\Engine\Volt\Compiler
+ *
+ * @param mixed $view
+ */
+ public function __construct(\Phalcon\Mvc\ViewBaseInterface $view = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the compiler options
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Sets a single compiler option
+ *
+ * @param string $option
+ * @param mixed $value
+ */
+ public function setOption($option, $value) {}
+
+ /**
+ * Returns a compiler's option
+ *
+ * @param string $option
+ * @return string
+ */
+ public function getOption($option) {}
+
+ /**
+ * Returns the compiler options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+ * Fires an event to registered extensions
+ *
+ * @param string $name
+ * @param array $arguments
+ * @return mixed
+ */
+ public final function fireExtensionEvent($name, $arguments = null) {}
+
+ /**
+ * Registers a Volt's extension
+ *
+ * @param mixed $extension
+ * @return Compiler
+ */
+ public function addExtension($extension) {}
+
+ /**
+ * Returns the list of extensions registered in Volt
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register a new function in the compiler
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return Compiler
+ */
+ public function addFunction($name, $definition) {}
+
+ /**
+ * Register the user registered functions
+ *
+ * @return array
+ */
+ public function getFunctions() {}
+
+ /**
+ * Register a new filter in the compiler
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return Compiler
+ */
+ public function addFilter($name, $definition) {}
+
+ /**
+ * Register the user registered filters
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+ /**
+ * Set a unique prefix to be used as prefix for compiled variables
+ *
+ * @param string $prefix
+ * @return Compiler
+ */
+ public function setUniquePrefix($prefix) {}
+
+ /**
+ * Return a unique prefix to be used as prefix for compiled variables and contexts
+ *
+ * @return string
+ */
+ public function getUniquePrefix() {}
+
+ /**
+ * Resolves attribute reading
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function attributeReader($expr) {}
+
+ /**
+ * Resolves function intermediate code into PHP function calls
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function functionCall($expr) {}
+
+ /**
+ * Resolves filter intermediate code into a valid PHP expression
+ *
+ * @param array $test
+ * @param string $left
+ * @return string
+ */
+ public function resolveTest($test, $left) {}
+
+ /**
+ * Resolves filter intermediate code into PHP function calls
+ *
+ * @param array $filter
+ * @param string $left
+ * @return string
+ */
+ final protected function resolveFilter($filter, $left) {}
+
+ /**
+ * Resolves an expression node in an AST volt tree
+ *
+ * @param array $expr
+ * @return string
+ */
+ final public function expression($expr) {}
+
+ /**
+ * Compiles a block of statements
+ *
+ * @param array $statements
+ * @return string|array
+ */
+ final protected function _statementListOrExtends($statements) {}
+
+ /**
+ * Compiles a "foreach" intermediate code representation into plain PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileForeach($statement, $extendsMode = false) {}
+
+ /**
+ * Generates a 'forelse' PHP code
+ *
+ * @return string
+ */
+ public function compileForElse() {}
+
+ /**
+ * Compiles a 'if' statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileIf($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "elseif" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileElseIf($statement) {}
+
+ /**
+ * Compiles a "cache" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileCache($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "set" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileSet($statement) {}
+
+ /**
+ * Compiles a "do" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileDo($statement) {}
+
+ /**
+ * Compiles a "return" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileReturn($statement) {}
+
+ /**
+ * Compiles a "autoescape" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileAutoEscape($statement, $extendsMode) {}
+
+ /**
+ * Compiles a '{{' '}}' statement returning PHP code
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileEcho($statement) {}
+
+ /**
+ * Compiles a 'include' statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileInclude($statement) {}
+
+ /**
+ * Compiles macros
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileMacro($statement, $extendsMode) {}
+
+ /**
+ * Compiles calls to macros
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileCall($statement, $extendsMode) {}
+
+ /**
+ * Traverses a statement list compiling each of its nodes
+ *
+ * @param array $statements
+ * @param bool $extendsMode
+ * @return string
+ */
+ final protected function _statementList($statements, $extendsMode = false) {}
+
+ /**
+ * Compiles a Volt source code returning a PHP plain version
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ protected function _compileSource($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a string
+ *
+ * echo $compiler->compileString('{{ "hello world" }}');
+ *
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileString($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file forcing the destination path
+ *
+ * $compiler->compile('views/layouts/main.volt', 'views/layouts/main.volt.php');
+ *
+ *
+ * @param string $path
+ * @param string $compiledPath
+ * @param boolean $extendsMode
+ * @return string|array
+ */
+ public function compileFile($path, $compiledPath, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file applying the compiler options
+ * This method does not return the compiled path if the template was not compiled
+ *
+ * $compiler->compile('views/layouts/main.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ *
+ * @param string $templatePath
+ * @param bool $extendsMode
+ */
+ public function compile($templatePath, $extendsMode = false) {}
+
+ /**
+ * Returns the path that is currently being compiled
+ *
+ * @return string
+ */
+ public function getTemplatePath() {}
+
+ /**
+ * Returns the path to the last compiled template
+ *
+ * @return string
+ */
+ public function getCompiledTemplatePath() {}
+
+ /**
+ * Parses a Volt template returning its intermediate representation
+ *
+ * print_r($compiler->parse('{{ 3 + 2 }}'));
+ *
+ *
+ * @param string $viewCode
+ * @return array
+ */
+ public function parse($viewCode) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/paginator/Adapter.php b/ide/2.0.5/Phalcon/paginator/Adapter.php
new file mode 100644
index 000000000..8a4dcf3fe
--- /dev/null
+++ b/ide/2.0.5/Phalcon/paginator/Adapter.php
@@ -0,0 +1,44 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => Robots::find(),
+ * "limit" => 25,
+ * "page" => $currentPage
+ * )
+ * );
+ * $paginate = $paginator->getPaginate();
+ *
+ */
+class Model extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\Model constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdclass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/paginator/adapter/NativeArray.php b/ide/2.0.5/Phalcon/paginator/adapter/NativeArray.php
new file mode 100644
index 000000000..d9dc50611
--- /dev/null
+++ b/ide/2.0.5/Phalcon/paginator/adapter/NativeArray.php
@@ -0,0 +1,46 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => array(
+ * array('id' => 1, 'name' => 'Artichoke'),
+ * array('id' => 2, 'name' => 'Carrots'),
+ * array('id' => 3, 'name' => 'Beet'),
+ * array('id' => 4, 'name' => 'Lettuce'),
+ * array('id' => 5, 'name' => '')
+ * ),
+ * "limit" => 2,
+ * "page" => $currentPage
+ * )
+ * );
+ *
+ */
+class NativeArray extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of the paginator
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\NativeArray constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/paginator/adapter/QueryBuilder.php b/ide/2.0.5/Phalcon/paginator/adapter/QueryBuilder.php
new file mode 100644
index 000000000..3a6af396f
--- /dev/null
+++ b/ide/2.0.5/Phalcon/paginator/adapter/QueryBuilder.php
@@ -0,0 +1,69 @@
+
+ * $builder = $this->modelsManager->createBuilder()
+ * ->columns('id, name')
+ * ->from('Robots')
+ * ->orderBy('name');
+ * $paginator = new Phalcon\Paginator\Adapter\QueryBuilder(array(
+ * "builder" => $builder,
+ * "limit"=> 20,
+ * "page" => 1
+ * ));
+ *
+ */
+class QueryBuilder extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config;
+
+ /**
+ * Paginator's data
+ */
+ protected $_builder;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\QueryBuilder
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Get the current page number
+ *
+ * @return int
+ */
+ public function getCurrentPage() {}
+
+ /**
+ * Set query builder object
+ *
+ * @param mixed $builder
+ * @return QueryBuilder
+ */
+ public function setQueryBuilder(\Phalcon\Mvc\Model\Query\Builder $builder) {}
+
+ /**
+ * Get query builder object
+ *
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function getQueryBuilder() {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/queue/Beanstalk.php b/ide/2.0.5/Phalcon/queue/Beanstalk.php
new file mode 100644
index 000000000..f5377b197
--- /dev/null
+++ b/ide/2.0.5/Phalcon/queue/Beanstalk.php
@@ -0,0 +1,135 @@
+
+ * $session->setOptions(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ *
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get internal options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+ * Set session name
+ *
+ * @param string $name
+ */
+ public function setName($name) {}
+
+ /**
+ * Get session name
+ */
+ public function getName() {}
+
+ /**
+ * Gets a session variable from an application context
+ *
+ * @param string $index
+ * @param mixed $defaultValue
+ * @param boolean $remove
+ * @return mixed
+ */
+ public function get($index, $defaultValue = null, $remove = false) {}
+
+ /**
+ * Sets a session variable in an application context
+ *
+ * $session->set('auth', 'yes');
+ *
+ *
+ * @param string $index
+ * @param string $value
+ */
+ public function set($index, $value) {}
+
+ /**
+ * Check whether a session variable is set in an application context
+ *
+ * var_dump($session->has('auth'));
+ *
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function has($index) {}
+
+ /**
+ * Removes a session variable from an application context
+ *
+ * $session->remove('auth');
+ *
+ *
+ * @param string $index
+ */
+ public function remove($index) {}
+
+ /**
+ * Returns active session id
+ *
+ * echo $session->getId();
+ *
+ *
+ * @return string
+ */
+ public function getId() {}
+
+ /**
+ * Set the current session id
+ *
+ * $session->setId($id);
+ *
+ *
+ * @param string $id
+ */
+ public function setId($id) {}
+
+ /**
+ * Check whether the session has been started
+ *
+ * var_dump($session->isStarted());
+ *
+ *
+ * @return bool
+ */
+ public function isStarted() {}
+
+ /**
+ * Destroys the active session
+ *
+ * var_dump($session->destroy());
+ *
+ *
+ * @return bool
+ */
+ public function destroy() {}
+
+ /**
+ * Returns the status of the current session. For PHP 5.3 this function will always return SESSION_NONE
+ *
+ * var_dump($session->status());
+ * // PHP 5.4 and above will give meaningful messages, 5.3 gets SESSION_NONE always
+ * if ($session->status() !== $session::SESSION_ACTIVE) {
+ * $session->start();
+ * }
+ *
+ *
+ * @return int
+ */
+ public function status() {}
+
+ /**
+ * Alias: Gets a session variable from an application context
+ *
+ * @param string $index
+ * @return mixed
+ */
+ public function __get($index) {}
+
+ /**
+ * Alias: Sets a session variable in an application context
+ *
+ * @param string $index
+ * @param string $value
+ */
+ public function __set($index, $value) {}
+
+ /**
+ * Alias: Check whether a session variable is set in an application context
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function __isset($index) {}
+
+ /**
+ * Alias: Removes a session variable from an application context
+ *
+ * @param string $index
+ */
+ public function __unset($index) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/session/AdapterInterface.php b/ide/2.0.5/Phalcon/session/AdapterInterface.php
new file mode 100644
index 000000000..814efc411
--- /dev/null
+++ b/ide/2.0.5/Phalcon/session/AdapterInterface.php
@@ -0,0 +1,84 @@
+
+ * $user = new \Phalcon\Session\Bag('user');
+ * $user->name = "Kimbra Johnson";
+ * $user->age = 22;
+ *
+ */
+class Bag implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Session\BagInterface, \IteratorAggregate, \ArrayAccess, \Countable
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_name = null;
+
+
+ protected $_data;
+
+
+ protected $_initialized = false;
+
+
+ protected $_session;
+
+
+ /**
+ * Phalcon\Session\Bag constructor
+ *
+ * @param string $name
+ */
+ public function __construct($name) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed
+ */
+ public function initialize() {}
+
+ /**
+ * Destroyes the session bag
+ *
+ * $user->destroy();
+ *
+ */
+ public function destroy() {}
+
+ /**
+ * Sets a value in the session bag
+ *
+ * $user->set('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function set($property, $value) {}
+
+ /**
+ * Magic setter to assign values to the session bag
+ *
+ * $user->name = "Kimbra";
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Obtains a value from the session bag optionally setting a default value
+ *
+ * echo $user->get('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $defaultValue
+ * @return mixed
+ */
+ public function get($property, $defaultValue = null) {}
+
+ /**
+ * Magic getter to obtain values from the session bag
+ *
+ * echo $user->name;
+ *
+ *
+ * @param string $property
+ * @return mixed
+ */
+ public function __get($property) {}
+
+ /**
+ * Check whether a property is defined in the internal bag
+ *
+ * var_dump($user->has('name'));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function has($property) {}
+
+ /**
+ * Magic isset to check whether a property is defined in the bag
+ *
+ * var_dump(isset($user['name']));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Removes a property from the internal bag
+ *
+ * $user->remove('name');
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function remove($property) {}
+
+ /**
+ * Magic unset to remove items using the array syntax
+ *
+ * unset($user['name']);
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __unset($property) {}
+
+ /**
+ * Return length of bag
+ *
+ * echo $user->count();
+ *
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Returns the bag iterator
+ *
+ * @return \ArrayIterator
+ */
+ public final function getIterator() {}
+
+ /**
+ * @param string $property
+ * @param mixed $value
+ */
+ public final function offsetSet($property, $value) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetExists($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetUnset($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetGet($property) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/session/BagInterface.php b/ide/2.0.5/Phalcon/session/BagInterface.php
new file mode 100644
index 000000000..c36cc1973
--- /dev/null
+++ b/ide/2.0.5/Phalcon/session/BagInterface.php
@@ -0,0 +1,71 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Files extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+}
diff --git a/ide/2.0.5/Phalcon/session/adapter/Libmemcached.php b/ide/2.0.5/Phalcon/session/adapter/Libmemcached.php
new file mode 100644
index 000000000..54ec0e0ad
--- /dev/null
+++ b/ide/2.0.5/Phalcon/session/adapter/Libmemcached.php
@@ -0,0 +1,88 @@
+
+ * $session = new Phalcon\Session\Adapter\Libmemcached(array(
+ * 'servers' => array(
+ * array('host' => 'localhost', 'port' => 11211, 'weight' => 1),
+ * ),
+ * 'client' => array(
+ * Memcached::OPT_HASH => Memcached::HASH_MD5,
+ * Memcached::OPT_PREFIX_KEY => 'prefix.',
+ * ),
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Libmemcached extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_libmemcached = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getLibmemcached() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Libmemcached constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options) {}
+
+ /**
+ * @return bool
+ */
+ public function open() {}
+
+ /**
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @return bool
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/session/adapter/Memcache.php b/ide/2.0.5/Phalcon/session/adapter/Memcache.php
new file mode 100644
index 000000000..83b9edf17
--- /dev/null
+++ b/ide/2.0.5/Phalcon/session/adapter/Memcache.php
@@ -0,0 +1,79 @@
+
+ * $session = new \Phalcon\Session\Adapter\Memcache(array(
+ * 'uniqueId' => 'my-private-app'
+ * 'host' => '127.0.0.1',
+ * 'port' => 11211,
+ * 'persistent' => TRUE,
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Memcache extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_memcache = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getMemcache() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Memcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = array()) {}
+
+
+ public function open() {}
+
+
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.5/Phalcon/tag/Exception.php b/ide/2.0.5/Phalcon/tag/Exception.php
new file mode 100644
index 000000000..8d2604755
--- /dev/null
+++ b/ide/2.0.5/Phalcon/tag/Exception.php
@@ -0,0 +1,12 @@
+
+ * print_r($messages[0]);
+ *
+ *
+ * @param int $index
+ * @return \Phalcon\Validation\Message
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $messages[0] = new \Phalcon\Validation\Message('This is a message');
+ *
+ *
+ * @param int $index
+ * @param \Phalcon\Validation\Message $message
+ */
+ public function offsetSet($index, $message) {}
+
+ /**
+ * Checks if an index exists
+ *
+ * var_dump(isset($message['database']));
+ *
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Removes a message from the list
+ *
+ * unset($message['database']);
+ *
+ *
+ * @param string $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Appends a message to the group
+ *
+ * $messages->appendMessage(new \Phalcon\Validation\Message('This is a message'));
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Validation\MessageInterface $message) {}
+
+ /**
+ * Appends an array of messages to the group
+ *
+ * $messages->appendMessages($messagesArray);
+ *
+ *
+ * @param \Phalcon\Validation\MessageInterface[] $messages
+ */
+ public function appendMessages($messages) {}
+
+ /**
+ * Filters the message group by field name
+ *
+ * @param string $fieldName
+ * @return array
+ */
+ public function filter($fieldName) {}
+
+ /**
+ * Returns the number of messages in the list
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current message in the iterator
+ *
+ * @return \Phalcon\Validation\Message
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current message in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable when exporting
+ *
+ * @param array $group
+ * @return \Phalcon\Validation\Message\Group
+ */
+ public static function __set_state($group) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Alnum.php b/ide/2.0.5/Phalcon/validation/validator/Alnum.php
new file mode 100644
index 000000000..96250226c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Alnum.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alnum as AlnumValidator;
+ * $validator->add('username', new AlnumValidator(array(
+ * 'message' => ':field must contain only alphanumeric characters'
+ * )));
+ *
+ */
+class Alnum extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Alpha.php b/ide/2.0.5/Phalcon/validation/validator/Alpha.php
new file mode 100644
index 000000000..3860505fd
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Alpha.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alpha as AlphaValidator;
+ * $validator->add('username', new AlphaValidator(array(
+ * 'message' => ':field must contain only letters'
+ * )));
+ *
+ */
+class Alpha extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Between.php b/ide/2.0.5/Phalcon/validation/validator/Between.php
new file mode 100644
index 000000000..9a765abd7
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Between.php
@@ -0,0 +1,30 @@
+
+ * use Phalcon\Validation\Validator\Between;
+ * validator->add('name', new Between(array(
+ * 'minimum' => 0,
+ * 'maximum' => 100,
+ * 'message' => 'The price must be between 0 and 100'
+ * )));
+ *
+ */
+class Between extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Confirmation.php b/ide/2.0.5/Phalcon/validation/validator/Confirmation.php
new file mode 100644
index 000000000..75e1ac710
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Confirmation.php
@@ -0,0 +1,37 @@
+
+ * use Phalcon\Validation\Validator\Confirmation;
+ * $validator->add('password', new Confirmation(array(
+ * 'message' => 'Password doesn\'t match confirmation',
+ * 'with' => 'confirmPassword'
+ * )));
+ *
+ */
+class Confirmation extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+ /**
+ * Compare strings
+ *
+ * @param string $a
+ * @param string $b
+ * @return bool
+ */
+ protected final function compare($a, $b) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Digit.php b/ide/2.0.5/Phalcon/validation/validator/Digit.php
new file mode 100644
index 000000000..dae4e4dbe
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Digit.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Digit as DigitValidator;
+ * $validator->add('height', new DigitValidator(array(
+ * 'message' => ':field must be numeric'
+ * )));
+ *
+ */
+class Digit extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Email.php b/ide/2.0.5/Phalcon/validation/validator/Email.php
new file mode 100644
index 000000000..8951305fc
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Email.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Email as EmailValidator;
+ * $validator->add('email', new EmailValidator(array(
+ * 'message' => 'The e-mail is not valid'
+ * )));
+ *
+ */
+class Email extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/ExclusionIn.php b/ide/2.0.5/Phalcon/validation/validator/ExclusionIn.php
new file mode 100644
index 000000000..d6bd01efa
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/ExclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\ExclusionIn;
+ * $validator->add('status', new ExclusionIn(array(
+ * 'message' => 'The status must not be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class ExclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/File.php b/ide/2.0.5/Phalcon/validation/validator/File.php
new file mode 100644
index 000000000..96121dc85
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/File.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\File as FileValidator;
+ * $validator->add('file', new FileValidator(array(
+ * 'maxSize' => '2M',
+ * 'messageSize' => ':field exceeds the max filesize (:max)',
+ * 'allowedTypes' => array('image/jpeg', 'image/png'),
+ * 'messageType' => 'Allowed file types are :types',
+ * 'maxResolution' => '800x600',
+ * 'messageMaxResolution' => 'Max resolution of :field is :max'
+ * )));
+ *
+ */
+class File extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Identical.php b/ide/2.0.5/Phalcon/validation/validator/Identical.php
new file mode 100644
index 000000000..d5ee453cc
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Identical.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Identical;
+ * $validator->add('terms', new Identical(array(
+ * 'accepted' => 'yes',
+ * 'message' => 'Terms and conditions must be accepted'
+ * )));
+ *
+ */
+class Identical extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/InclusionIn.php b/ide/2.0.5/Phalcon/validation/validator/InclusionIn.php
new file mode 100644
index 000000000..4bee62023
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/InclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\InclusionIn;
+ * $validator->add('status', new InclusionIn(array(
+ * 'message' => 'The status must be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class InclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Numericality.php b/ide/2.0.5/Phalcon/validation/validator/Numericality.php
new file mode 100644
index 000000000..5b68ec926
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Numericality.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Numericality;
+ * $validator->add('price', new Numericality(array(
+ * 'message' => ':field is not numeric'
+ * )));
+ *
+ */
+class Numericality extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/PresenceOf.php b/ide/2.0.5/Phalcon/validation/validator/PresenceOf.php
new file mode 100644
index 000000000..30ba729ed
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/PresenceOf.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\PresenceOf;
+ * $validator->add('name', new PresenceOf(array(
+ * 'message' => 'The name is required'
+ * )));
+ *
+ */
+class PresenceOf extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Regex.php b/ide/2.0.5/Phalcon/validation/validator/Regex.php
new file mode 100644
index 000000000..8b73552b6
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Regex.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Regex as RegexValidator;
+ * $validator->add('created_at', new RegexValidator(array(
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/',
+ * 'message' => 'The creation date is invalid'
+ * )));
+ *
+ */
+class Regex extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/StringLength.php b/ide/2.0.5/Phalcon/validation/validator/StringLength.php
new file mode 100644
index 000000000..2bafa9675
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/StringLength.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\StringLength as StringLength;
+ * $validation->add('name_last', new StringLength(array(
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ *
+ */
+class StringLength extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Uniqueness.php b/ide/2.0.5/Phalcon/validation/validator/Uniqueness.php
new file mode 100644
index 000000000..79ef4083c
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Uniqueness.php
@@ -0,0 +1,35 @@
+
+ * use Phalcon\Validation\Validator\Uniqueness as UniquenessValidator;
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'message' => ':field must be unique'
+ * )));
+ *
+ * Different attribute from the field
+ *
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'attribute' => 'nick'
+ * )));
+ *
+ */
+class Uniqueness extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.5/Phalcon/validation/validator/Url.php b/ide/2.0.5/Phalcon/validation/validator/Url.php
new file mode 100644
index 000000000..76ab65b91
--- /dev/null
+++ b/ide/2.0.5/Phalcon/validation/validator/Url.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Url as UrlValidator;
+ * $validator->add('url', new UrlValidator(array(
+ * 'message' => ':field must be a url'
+ * )));
+ *
+ */
+class Url extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Acl.php b/ide/2.0.6/Phalcon/Acl.php
new file mode 100644
index 000000000..54a8d3549
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Acl.php
@@ -0,0 +1,45 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * //Default action is deny access
+ * $acl->setDefaultAction(\Phalcon\Acl::DENY);
+ * //Create some roles
+ * $roleAdmins = new \Phalcon\Acl\Role('Administrators', 'Super-User role');
+ * $roleGuests = new \Phalcon\Acl\Role('Guests');
+ * //Add "Guests" role to acl
+ * $acl->addRole($roleGuests);
+ * //Add "Designers" role to acl
+ * $acl->addRole('Designers');
+ * //Define the "Customers" resource
+ * $customersResource = new \Phalcon\Acl\Resource('Customers', 'Customers management');
+ * //Add "customers" resource with a couple of operations
+ * $acl->addResource($customersResource, 'search');
+ * $acl->addResource($customersResource, array('create', 'update'));
+ * //Set access level for roles into resources
+ * $acl->allow('Guests', 'Customers', 'search');
+ * $acl->allow('Guests', 'Customers', 'create');
+ * $acl->deny('Guests', 'Customers', 'update');
+ * //Check whether role has access to the operations
+ * $acl->isAllowed('Guests', 'Customers', 'edit'); //Returns 0
+ * $acl->isAllowed('Guests', 'Customers', 'search'); //Returns 1
+ * $acl->isAllowed('Guests', 'Customers', 'create'); //Returns 1
+ *
+ */
+abstract class Acl
+{
+
+ const ALLOW = 1;
+
+
+ const DENY = 0;
+
+
+}
diff --git a/ide/2.0.6/Phalcon/Config.php b/ide/2.0.6/Phalcon/Config.php
new file mode 100644
index 000000000..b3112b0da
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Config.php
@@ -0,0 +1,145 @@
+
+ * $config = new \Phalcon\Config(array(
+ * "database" => array(
+ * "adapter" => "Mysql",
+ * "host" => "localhost",
+ * "username" => "scott",
+ * "password" => "cheetah",
+ * "dbname" => "test_db"
+ * ),
+ * "phalcon" => array(
+ * "controllersDir" => "../app/controllers/",
+ * "modelsDir" => "../app/models/",
+ * "viewsDir" => "../app/views/"
+ * )
+ * ));
+ *
+ */
+class Config implements \ArrayAccess, \Countable
+{
+
+ /**
+ * Phalcon\Config constructor
+ *
+ * @param array $arrayConfig
+ */
+ public function __construct($arrayConfig = null) {}
+
+ /**
+ * Allows to check whether an attribute is defined using the array-syntax
+ *
+ * var_dump(isset($config['database']));
+ *
+ *
+ * @param mixed $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets an attribute from the configuration, if the attribute isn't defined returns null
+ * If the value is exactly null or is not defined the default value will be used instead
+ *
+ * echo $config->get('controllersDir', '../app/controllers/');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $defaultValue
+ */
+ public function get($index, $defaultValue = null) {}
+
+ /**
+ * Gets an attribute using the array-syntax
+ *
+ * print_r($config['database']);
+ *
+ *
+ * @param mixed $index
+ * @return string
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $config['database'] = array('type' => 'Sqlite');
+ *
+ *
+ * @param mixed $index
+ * @param mixed $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Unsets an attribute using the array-syntax
+ *
+ * unset($config['database']);
+ *
+ *
+ * @param mixed $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Merges a configuration into the current one
+ *
+ * $appConfig = new \Phalcon\Config(array('database' => array('host' => 'localhost')));
+ * $globalConfig->merge($config2);
+ *
+ *
+ * @param mixed $config
+ * @return Config
+ */
+ public function merge(Config $config) {}
+
+ /**
+ * Converts recursively the object to an array
+ *
+ * print_r($config->toArray());
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Returns the count of properties set in the config
+ *
+ * print count($config);
+ *
+ * or
+ *
+ * print $config->count();
+ *
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Restores the state of a Phalcon\Config object
+ *
+ * @param array $data
+ * @return Config
+ */
+ public static function __set_state($data) {}
+
+ /**
+ * Helper method for merge configs (forwarding nested config instance)
+ *
+ * @param Config $config
+ * @param Config $instance = null
+ * @return Config config
+ */
+ protected final function _merge(Config $config, $instance = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Crypt.php b/ide/2.0.6/Phalcon/Crypt.php
new file mode 100644
index 000000000..a2c8d1c49
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Crypt.php
@@ -0,0 +1,190 @@
+
+ * $crypt = new \Phalcon\Crypt();
+ * $key = 'le password';
+ * $text = 'This is a secret text';
+ * $encrypted = $crypt->encrypt($text, $key);
+ * echo $crypt->decrypt($encrypted, $key);
+ *
+ */
+class Crypt implements \Phalcon\CryptInterface
+{
+
+ const PADDING_DEFAULT = 0;
+
+
+ const PADDING_ANSI_X_923 = 1;
+
+
+ const PADDING_PKCS7 = 2;
+
+
+ const PADDING_ISO_10126 = 3;
+
+
+ const PADDING_ISO_IEC_7816_4 = 4;
+
+
+ const PADDING_ZERO = 5;
+
+
+ const PADDING_SPACE = 6;
+
+
+ protected $_key;
+
+
+ protected $_padding = 0;
+
+
+ protected $_mode = "cbc";
+
+
+ protected $_cipher = "rijndael-256";
+
+
+ /**
+ * Changes the padding scheme used
+ *
+ * @param int $scheme
+ * @return \Phalcon\CryptInterface
+ */
+ public function setPadding($scheme) {}
+
+ /**
+ * Sets the cipher algorithm
+ *
+ * @param string $cipher
+ * @return Crypt
+ */
+ public function setCipher($cipher) {}
+
+ /**
+ * Returns the current cipher
+ *
+ * @return string
+ */
+ public function getCipher() {}
+
+ /**
+ * Sets the encrypt/decrypt mode
+ *
+ * @param string $mode
+ * @return Crypt
+ */
+ public function setMode($mode) {}
+
+ /**
+ * Returns the current encryption mode
+ *
+ * @return string
+ */
+ public function getMode() {}
+
+ /**
+ * Sets the encryption key
+ *
+ * @param string $key
+ * @return Crypt
+ */
+ public function setKey($key) {}
+
+ /**
+ * Returns the encryption key
+ *
+ * @return string
+ */
+ public function getKey() {}
+
+ /**
+ * Pads texts before encryption
+ *
+ * @see http://www.di-mgt.com.au/cryptopad.html
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ */
+ protected function _cryptPadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Removes padding @a padding_type from @a text
+ * If the function detects that the text was not padded, it will return it unmodified
+ *
+ * @param string $text
+ * @param string $mode
+ * @param int $blockSize
+ * @param int $paddingType
+ * @param return_value $Result, possibly unpadded
+ * @param text $Message to be unpadded
+ * @param mode $Encryption mode; unpadding is applied only in CBC or ECB mode
+ * @param block_size $Cipher block size
+ * @param padding_type $Padding scheme
+ */
+ protected function _cryptUnpadText($text, $mode, $blockSize, $paddingType) {}
+
+ /**
+ * Encrypts a text
+ *
+ * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
+ *
+ *
+ * @param string $text
+ * @param string $key
+ * @return string
+ */
+ public function encrypt($text, $key = null) {}
+
+ /**
+ * Decrypts an encrypted text
+ *
+ * echo $crypt->decrypt($encrypted, "decrypt password");
+ *
+ *
+ * @param string $text
+ * @param mixed $key
+ * @return string
+ */
+ public function decrypt($text, $key = null) {}
+
+ /**
+ * Encrypts a text returning the result as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function encryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Decrypt a text that is coded as a base64 string
+ *
+ * @param string $text
+ * @param mixed $key
+ * @param bool $safe
+ * @return string
+ */
+ public function decryptBase64($text, $key = null, $safe = false) {}
+
+ /**
+ * Returns a list of available cyphers
+ *
+ * @return array
+ */
+ public function getAvailableCiphers() {}
+
+ /**
+ * Returns a list of available modes
+ *
+ * @return array
+ */
+ public function getAvailableModes() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/CryptInterface.php b/ide/2.0.6/Phalcon/CryptInterface.php
new file mode 100644
index 000000000..529103de4
--- /dev/null
+++ b/ide/2.0.6/Phalcon/CryptInterface.php
@@ -0,0 +1,107 @@
+
+ * try {
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306',
+ * ));
+ * $result = $connection->query("SELECTFROM robots LIMIT 5");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetch()) {
+ * print_r($robot);
+ * }
+ * } catch (Phalcon\Db\Exception $e) {
+ * echo $e->getMessage(), PHP_EOL;
+ * }
+ *
+ */
+abstract class Db
+{
+
+ const FETCH_LAZY = 1;
+
+
+ const FETCH_ASSOC = 2;
+
+
+ const FETCH_NAMED = 11;
+
+
+ const FETCH_NUM = 3;
+
+
+ const FETCH_BOTH = 4;
+
+
+ const FETCH_OBJ = 5;
+
+
+ const FETCH_BOUND = 6;
+
+
+ const FETCH_COLUMN = 7;
+
+
+ const FETCH_CLASS = 8;
+
+
+ const FETCH_INTO = 9;
+
+
+ const FETCH_FUNC = 10;
+
+
+ const FETCH_GROUP = 65536;
+
+
+ const FETCH_UNIQUE = 196608;
+
+
+ const FETCH_KEY_PAIR = 12;
+
+
+ const FETCH_CLASSTYPE = 262144;
+
+
+ const FETCH_SERIALIZE = 524288;
+
+
+ const FETCH_PROPS_LATE = 1048576;
+
+
+ /**
+ * Enables/disables options in the Database component
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Debug.php b/ide/2.0.6/Phalcon/Debug.php
new file mode 100644
index 000000000..a99a489f8
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Debug.php
@@ -0,0 +1,192 @@
+
+ * $di = new \Phalcon\Di();
+ * //Using a string definition
+ * $di->set("request", "Phalcon\Http\Request", true);
+ * //Using an anonymous function
+ * $di->set("request", function(){
+ * return new \Phalcon\Http\Request();
+ * }, true);
+ * $request = $di->getRequest();
+ *
+ */
+class Di implements \Phalcon\DiInterface
+{
+ /**
+ * List of registered services
+ */
+ protected $_services;
+
+ /**
+ * List of shared instances
+ */
+ protected $_sharedInstances;
+
+ /**
+ * To know if the latest resolved instance was shared or not
+ */
+ protected $_freshInstance = false;
+
+ /**
+ * Events Manager
+ *
+ * @var \Phalcon\Events\ManagerInterface
+ */
+ protected $_eventsManager;
+
+ /**
+ * Latest DI build
+ */
+ static protected $_default;
+
+
+ /**
+ * Phalcon\Di constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the internal event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setInternalEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getInternalEventsManager() {}
+
+ /**
+ * Registers a service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function set($name, $definition, $shared = false) {}
+
+ /**
+ * Registers an "always shared" service in the services container
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setShared($name, $definition) {}
+
+ /**
+ * Removes a service in the services container
+ * It also removes any shared instance created for the service
+ *
+ * @param string $name
+ */
+ public function remove($name) {}
+
+ /**
+ * Attempts to register a service in the services container
+ * Only is successful if a service hasn't been registered previously
+ * with the same name
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param bool $shared
+ * @return bool|\Phalcon\Di\ServiceInterface
+ */
+ public function attempt($name, $definition, $shared = false) {}
+
+ /**
+ * Sets a service using a raw Phalcon\Di\Service definition
+ *
+ * @param string $name
+ * @param mixed $rawDefinition
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function setRaw($name, \Phalcon\Di\ServiceInterface $rawDefinition) {}
+
+ /**
+ * Returns a service definition without resolving
+ *
+ * @param string $name
+ */
+ public function getRaw($name) {}
+
+ /**
+ * Returns a Phalcon\Di\Service instance
+ *
+ * @param string $name
+ * @return \Phalcon\Di\ServiceInterface
+ */
+ public function getService($name) {}
+
+ /**
+ * Resolves the service based on its configuration
+ *
+ * @param string $name
+ * @param mixed $parameters
+ */
+ public function get($name, $parameters = null) {}
+
+ /**
+ * Resolves a service, the resolved service is stored in the DI, subsequent requests for this service will return the same instance
+ *
+ * @param string $name
+ * @param array $parameters
+ * @return mixed
+ */
+ public function getShared($name, $parameters = null) {}
+
+ /**
+ * Check whether the DI contains a service by a name
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Check whether the last service obtained via getShared produced a fresh instance or an existing one
+ *
+ * @return bool
+ */
+ public function wasFreshInstance() {}
+
+ /**
+ * Return the services registered in the DI
+ *
+ * @return \Phalcon\Di\Service
+ */
+ public function getServices() {}
+
+ /**
+ * Check if a service is registered using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetExists($name) {}
+
+ /**
+ * Allows to register a shared service using the array syntax
+ *
+ * $di["request"] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return boolean
+ */
+ public function offsetSet($name, $definition) {}
+
+ /**
+ * Allows to obtain a shared service using the array syntax
+ *
+ * var_dump($di["request"]);
+ *
+ *
+ * @param string $name
+ * @return mixed
+ */
+ public function offsetGet($name) {}
+
+ /**
+ * Removes a service from the services container using the array syntax
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function offsetUnset($name) {}
+
+ /**
+ * Magic method to get or set services using setters/getters
+ *
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ public function __call($method, $arguments = null) {}
+
+ /**
+ * Set a default dependency injection container to be obtained into static methods
+ *
+ * @param mixed $dependencyInjector
+ */
+ public static function setDefault(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Return the lastest DI created
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public static function getDefault() {}
+
+ /**
+ * Resets the internal default DI
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/DiInterface.php b/ide/2.0.6/Phalcon/DiInterface.php
new file mode 100644
index 000000000..53e5de99d
--- /dev/null
+++ b/ide/2.0.6/Phalcon/DiInterface.php
@@ -0,0 +1,134 @@
+
+ * $this->dispatcher->forward(array("controller" => "posts", "action" => "index"));
+ *
+ *
+ * @param array $forward
+ */
+ public function forward($forward) {}
+
+ /**
+ * Check if the current executed action was forwarded by another one
+ *
+ * @return bool
+ */
+ public function wasForwarded() {}
+
+ /**
+ * Possible class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getHandlerClass() {}
+
+ /**
+ * Set empty properties to their defaults (where defaults are available)
+ */
+ protected function _resolveEmptyProperties() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/DispatcherInterface.php b/ide/2.0.6/Phalcon/DispatcherInterface.php
new file mode 100644
index 000000000..1b5a292cc
--- /dev/null
+++ b/ide/2.0.6/Phalcon/DispatcherInterface.php
@@ -0,0 +1,120 @@
+
+ * $escaper = new \Phalcon\Escaper();
+ * $escaped = $escaper->escapeCss("font-family:
+ * $escaper->setEncoding('utf-8');
+ *
+ *
+ * @param string $encoding
+ */
+ public function setEncoding($encoding) {}
+
+ /**
+ * Returns the internal encoding used by the escaper
+ *
+ * @return string
+ */
+ public function getEncoding() {}
+
+ /**
+ * Sets the HTML quoting type for htmlspecialchars
+ *
+ * $escaper->setHtmlQuoteType(ENT_XHTML);
+ *
+ *
+ * @param int $quoteType
+ */
+ public function setHtmlQuoteType($quoteType) {}
+
+ /**
+ * Detect the character encoding of a string to be handled by an encoder
+ * Special-handling for chr(172) and chr(128) to chr(159) which fail to be detected by mb_detect_encoding()
+ *
+ * @param string $str
+ * @return string|null
+ */
+ public final function detectEncoding($str) {}
+
+ /**
+ * Utility to normalize a string's encoding to UTF-32.
+ *
+ * @param string $str
+ * @return string
+ */
+ public final function normalizeEncoding($str) {}
+
+ /**
+ * Escapes a HTML string. Internally uses htmlspecialchars
+ *
+ * @param string $text
+ * @return string
+ */
+ public function escapeHtml($text) {}
+
+ /**
+ * Escapes a HTML attribute string
+ *
+ * @param string $attribute
+ * @return string
+ */
+ public function escapeHtmlAttr($attribute) {}
+
+ /**
+ * Escape CSS strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $css
+ * @return string
+ */
+ public function escapeCss($css) {}
+
+ /**
+ * Escape javascript strings by replacing non-alphanumeric chars by their hexadecimal escaped representation
+ *
+ * @param string $js
+ * @return string
+ */
+ public function escapeJs($js) {}
+
+ /**
+ * Escapes a URL. Internally uses rawurlencode
+ *
+ * @param string $url
+ * @return string
+ */
+ public function escapeUrl($url) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/EscaperInterface.php b/ide/2.0.6/Phalcon/EscaperInterface.php
new file mode 100644
index 000000000..e8718dea2
--- /dev/null
+++ b/ide/2.0.6/Phalcon/EscaperInterface.php
@@ -0,0 +1,73 @@
+
+ * $filter = new \Phalcon\Filter();
+ * $filter->sanitize("some(one)@exa\\mple.com", "email"); // returns "someone@example.com"
+ * $filter->sanitize("hello<<", "string"); // returns "hello"
+ * $filter->sanitize("!100a019", "int"); // returns "100019"
+ * $filter->sanitize("!100a019.01a", "float"); // returns "100019.01"
+ *
+ */
+class Filter implements \Phalcon\FilterInterface
+{
+
+ const FILTER_EMAIL = "email";
+
+
+ const FILTER_ABSINT = "absint";
+
+
+ const FILTER_INT = "int";
+
+
+ const FILTER_INT_CAST = "int!";
+
+
+ const FILTER_STRING = "string";
+
+
+ const FILTER_FLOAT = "float";
+
+
+ const FILTER_FLOAT_CAST = "float!";
+
+
+ const FILTER_ALPHANUM = "alphanum";
+
+
+ const FILTER_TRIM = "trim";
+
+
+ const FILTER_STRIPTAGS = "striptags";
+
+
+ const FILTER_LOWER = "lower";
+
+
+ const FILTER_UPPER = "upper";
+
+
+ protected $_filters;
+
+
+ /**
+ * Adds a user-defined filter
+ *
+ * @param string $name
+ * @param mixed $handler
+ * @return Filter
+ */
+ public function add($name, $handler) {}
+
+ /**
+ * Sanitizes a value with a specified single or set of filters
+ *
+ * @param mixed $value
+ * @param mixed $filters
+ * @param bool $noRecursive
+ */
+ public function sanitize($value, $filters, $noRecursive = false) {}
+
+ /**
+ * Internal sanitize wrapper to filter_var
+ *
+ * @param mixed $value
+ * @param string $filter
+ */
+ protected function _sanitize($value, $filter) {}
+
+ /**
+ * Return the user-defined filters in the instance
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/FilterInterface.php b/ide/2.0.6/Phalcon/FilterInterface.php
new file mode 100644
index 000000000..5ebd2ee21
--- /dev/null
+++ b/ide/2.0.6/Phalcon/FilterInterface.php
@@ -0,0 +1,37 @@
+
+ * $flash->success("The record was successfully deleted");
+ * $flash->error("Cannot open the file");
+ *
+ */
+abstract class Flash
+{
+
+ protected $_cssClasses;
+
+
+ protected $_implicitFlush = true;
+
+
+ protected $_automaticHtml = true;
+
+
+ protected $_messages;
+
+
+ /**
+ * Phalcon\Flash constructor
+ *
+ * @param mixed $cssClasses
+ */
+ public function __construct($cssClasses = null) {}
+
+ /**
+ * Set whether the output must be implicitly flushed to the output or returned as string
+ *
+ * @param bool $implicitFlush
+ * @return \Phalcon\FlashInterface
+ */
+ public function setImplicitFlush($implicitFlush) {}
+
+ /**
+ * Set if the output must be implicitly formatted with HTML
+ *
+ * @param bool $automaticHtml
+ * @return \Phalcon\FlashInterface
+ */
+ public function setAutomaticHtml($automaticHtml) {}
+
+ /**
+ * Set an array with CSS classes to format the messages
+ *
+ * @param array $cssClasses
+ * @return \Phalcon\FlashInterface
+ */
+ public function setCssClasses($cssClasses) {}
+
+ /**
+ * Shows a HTML error message
+ *
+ * $flash->error('This is an error');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function error($message) {}
+
+ /**
+ * Shows a HTML notice/information message
+ *
+ * $flash->notice('This is an information');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function notice($message) {}
+
+ /**
+ * Shows a HTML success message
+ *
+ * $flash->success('The process was finished successfully');
+ *
+ *
+ * @param string $message
+ * @return string
+ */
+ public function success($message) {}
+
+ /**
+ * Shows a HTML warning message
+ *
+ * $flash->warning('Hey, this is important');
+ *
+ *
+ * @param mixed $message
+ * @return string
+ */
+ public function warning($message) {}
+
+ /**
+ * Outputs a message formatting it with HTML
+ *
+ * $flash->outputMessage('error', message);
+ *
+ *
+ * @param string $type
+ * @param string|array $message
+ */
+ public function outputMessage($type, $message) {}
+
+ /**
+ * Clears accumulated messages when implicit flush is disabled
+ */
+ public function clear() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/FlashInterface.php b/ide/2.0.6/Phalcon/FlashInterface.php
new file mode 100644
index 000000000..86ca19753
--- /dev/null
+++ b/ide/2.0.6/Phalcon/FlashInterface.php
@@ -0,0 +1,48 @@
+
+ * //Creates the autoloader
+ * $loader = new Loader();
+ * //Register some namespaces
+ * $loader->registerNamespaces(array(
+ * 'Example\Base' => 'vendor/example/base/',
+ * 'Example\Adapter' => 'vendor/example/adapter/',
+ * 'Example' => 'vendor/example/'
+ * ));
+ * //register autoloader
+ * $loader->register();
+ * //Requiring this class will automatically include file vendor/example/adapter/Some.php
+ * $adapter = Example\Adapter\Some();
+ *
+ */
+class Loader implements \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_eventsManager = null;
+
+
+ protected $_foundPath = null;
+
+
+ protected $_checkedPath = null;
+
+
+ protected $_prefixes = null;
+
+
+ protected $_classes = null;
+
+
+ protected $_extensions;
+
+
+ protected $_namespaces = null;
+
+
+ protected $_directories = null;
+
+
+ protected $_registered = false;
+
+
+ /**
+ * Phalcon\Loader constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the events manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets an array of file extensions that the loader must try in each attempt to locate the file
+ *
+ * @param array $extensions
+ * @return Loader
+ */
+ public function setExtensions($extensions) {}
+
+ /**
+ * Returns the file extensions registered in the loader
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register namespaces and their related directories
+ *
+ * @param array $namespaces
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerNamespaces($namespaces, $merge = false) {}
+
+ /**
+ * Returns the namespaces currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getNamespaces() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $prefixes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerPrefixes($prefixes, $merge = false) {}
+
+ /**
+ * Returns the prefixes currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getPrefixes() {}
+
+ /**
+ * Register directories in which "not found" classes could be found
+ *
+ * @param array $directories
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerDirs($directories, $merge = false) {}
+
+ /**
+ * Returns the directories currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getDirs() {}
+
+ /**
+ * Register classes and their locations
+ *
+ * @param array $classes
+ * @param bool $merge
+ * @return Loader
+ */
+ public function registerClasses($classes, $merge = false) {}
+
+ /**
+ * Returns the class-map currently registered in the autoloader
+ *
+ * @return array
+ */
+ public function getClasses() {}
+
+ /**
+ * Register the autoload method
+ *
+ * @return Loader
+ */
+ public function register() {}
+
+ /**
+ * Unregister the autoload method
+ *
+ * @return Loader
+ */
+ public function unregister() {}
+
+ /**
+ * Autoloads the registered classes
+ *
+ * @param string $className
+ * @return bool
+ */
+ public function autoLoad($className) {}
+
+ /**
+ * Get the path when a class was found
+ *
+ * @return string
+ */
+ public function getFoundPath() {}
+
+ /**
+ * Get the path the loader is checking for a path
+ *
+ * @return string
+ */
+ public function getCheckedPath() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Logger.php b/ide/2.0.6/Phalcon/Logger.php
new file mode 100644
index 000000000..6ea41067c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Logger.php
@@ -0,0 +1,53 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+abstract class Logger
+{
+
+ const SPECIAL = 9;
+
+
+ const CUSTOM = 8;
+
+
+ const DEBUG = 7;
+
+
+ const INFO = 6;
+
+
+ const NOTICE = 5;
+
+
+ const WARNING = 4;
+
+
+ const ERROR = 3;
+
+
+ const ALERT = 2;
+
+
+ const CRITICAL = 1;
+
+
+ const EMERGENCE = 0;
+
+
+ const EMERGENCY = 0;
+
+
+}
diff --git a/ide/2.0.6/Phalcon/Registry.php b/ide/2.0.6/Phalcon/Registry.php
new file mode 100644
index 000000000..560353724
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Registry.php
@@ -0,0 +1,150 @@
+
+ * $registry = new \Phalcon\Registry();
+ * // Set value
+ * $registry->something = 'something';
+ * // or
+ * $registry['something'] = 'something';
+ * // Get value
+ * $value = $registry->something;
+ * // or
+ * $value = $registry['something'];
+ * // Check if the key exists
+ * $exists = isset($registry->something);
+ * // or
+ * $exists = isset($registry['something']);
+ * // Unset
+ * unset($registry->something);
+ * // or
+ * unset($registry['something']);
+ *
+ * In addition to ArrayAccess, Phalcon\Registry also implements Countable
+ * (count($registry) will return the number of elements in the registry),
+ * Serializable and Iterator (you can iterate over the registry
+ * using a foreach loop) interfaces. For PHP 5.4 and higher, JsonSerializable
+ * interface is implemented.
+ * Phalcon\Registry is very fast (it is typically faster than any userspace
+ * implementation of the registry); however, this comes at a price:
+ * Phalcon\Registry is a final class and cannot be inherited from.
+ * Though Phalcon\Registry exposes methods like __get(), offsetGet(), count() etc,
+ * it is not recommended to invoke them manually (these methods exist mainly to
+ * match the interfaces the registry implements): $registry->__get('property')
+ * is several times slower than $registry->property.
+ * Internally all the magic methods (and interfaces except JsonSerializable)
+ * are implemented using object handlers or similar techniques: this allows
+ * to bypass relatively slow method calls.
+ */
+final class Registry implements \ArrayAccess, \Countable, \Iterator
+{
+
+ protected $_data;
+
+
+ /**
+ * Registry constructor
+ */
+ public final function __construct() {}
+
+ /**
+ * Checks if the element is present in the registry
+ *
+ * @param string $offset
+ * @return bool
+ */
+ public final function offsetExists($offset) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $offset
+ * @return variable
+ */
+ public final function offsetGet($offset) {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $offset
+ * @param mixed $value
+ */
+ public final function offsetSet($offset, $value) {}
+
+ /**
+ * Unsets an element in the registry
+ *
+ * @param string $offset
+ */
+ public final function offsetUnset($offset) {}
+
+ /**
+ * Checks how many elements are in the register
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Moves cursor to next row in the registry
+ */
+ public final function next() {}
+
+ /**
+ * Gets pointer number of active row in the registry
+ *
+ * @return int
+ */
+ public final function key() {}
+
+ /**
+ * Rewinds the registry cursor to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Checks if the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Obtains the current value in the internal iterator
+ */
+ public function current() {}
+
+ /**
+ * Sets an element in the registry
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public final function __set($key, $value) {}
+
+ /**
+ * Returns an index in the registry
+ *
+ * @param string $key
+ * @return variable
+ */
+ public final function __get($key) {}
+
+ /**
+ * @param string $key
+ * @return bool
+ */
+ public final function __isset($key) {}
+
+ /**
+ * @param string $key
+ */
+ public final function __unset($key) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Security.php b/ide/2.0.6/Phalcon/Security.php
new file mode 100644
index 000000000..0a44a9e35
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Security.php
@@ -0,0 +1,201 @@
+
+ * $login = $this->request->getPost('login');
+ * $password = $this->request->getPost('password');
+ * $user = Users::findFirstByLogin($login);
+ * if ($user) {
+ * if ($this->security->checkHash($password, $user->password)) {
+ * //The password is valid
+ * }
+ * }
+ *
+ */
+class Security implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const CRYPT_DEFAULT = 0;
+
+
+ const CRYPT_STD_DES = 1;
+
+
+ const CRYPT_EXT_DES = 2;
+
+
+ const CRYPT_MD5 = 3;
+
+
+ const CRYPT_BLOWFISH = 4;
+
+
+ const CRYPT_BLOWFISH_X = 5;
+
+
+ const CRYPT_BLOWFISH_Y = 6;
+
+
+ const CRYPT_SHA256 = 7;
+
+
+ const CRYPT_SHA512 = 8;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_workFactor = 8;
+
+
+ protected $_numberBytes = 16;
+
+
+ protected $_tokenKeySessionID = "$PHALCON/CSRF/KEY$";
+
+
+ protected $_tokenValueSessionID = "$PHALCON/CSRF$";
+
+
+ protected $_csrf;
+
+
+ protected $_defaultHash;
+
+
+ /**
+ * @param mixed $workFactor
+ */
+ public function setWorkFactor($workFactor) {}
+
+
+ public function getWorkFactor() {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @param long $randomBytes
+ */
+ public function setRandomBytes($randomBytes) {}
+
+ /**
+ * Returns a number of bytes to be generated by the openssl pseudo random generator
+ *
+ * @return string
+ */
+ public function getRandomBytes() {}
+
+ /**
+ * Generate a >22-length pseudo random string to be used as salt for passwords
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getSaltBytes($numberBytes = 0) {}
+
+ /**
+ * Creates a password hash using bcrypt with a pseudo random salt
+ *
+ * @param string $password
+ * @param int $workFactor
+ * @return string
+ */
+ public function hash($password, $workFactor = 0) {}
+
+ /**
+ * Checks a plain text password and its hash version to check if the password matches
+ *
+ * @param string $password
+ * @param string $passwordHash
+ * @param int $maxPassLength
+ * @return bool
+ */
+ public function checkHash($password, $passwordHash, $maxPassLength = 0) {}
+
+ /**
+ * Checks if a password hash is a valid bcrypt's hash
+ *
+ * @param string $passwordHash
+ * @return bool
+ */
+ public function isLegacyHash($passwordHash) {}
+
+ /**
+ * Generates a pseudo random token key to be used as input's name in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getTokenKey($numberBytes = null) {}
+
+ /**
+ * Generates a pseudo random token value to be used as input's value in a CSRF check
+ *
+ * @param int $numberBytes
+ * @return string
+ */
+ public function getToken($numberBytes = null) {}
+
+ /**
+ * Check if the CSRF token sent in the request is the same that the current in session
+ *
+ * @param mixed $tokenKey
+ * @param mixed $tokenValue
+ * @param bool $destroyIfValid
+ * @return bool
+ */
+ public function checkToken($tokenKey = null, $tokenValue = null, $destroyIfValid = true) {}
+
+ /**
+ * Returns the value of the CSRF token in session
+ *
+ * @return string
+ */
+ public function getSessionToken() {}
+
+ /**
+ * Removes the value of the CSRF token and key from session
+ */
+ public function destroyToken() {}
+
+ /**
+ * Computes a HMAC
+ *
+ * @param string $data
+ * @param string $key
+ * @param string $algo
+ * @param boolean $raw
+ */
+ public function computeHmac($data, $key, $algo, $raw = false) {}
+
+ /**
+ * Sets the default hash
+ *
+ * @param mixed $defaultHash
+ */
+ public function setDefaultHash($defaultHash) {}
+
+ /**
+ * Sets the default hash
+ */
+ public function getDefaultHash() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Session.php b/ide/2.0.6/Phalcon/Session.php
new file mode 100644
index 000000000..76e72cff4
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Session.php
@@ -0,0 +1,23 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+abstract class Session
+{
+
+}
diff --git a/ide/2.0.6/Phalcon/Tag.php b/ide/2.0.6/Phalcon/Tag.php
new file mode 100644
index 000000000..6e420778b
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Tag.php
@@ -0,0 +1,718 @@
+
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefault("name", "peter");
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function setDefault($id, $value) {}
+
+ /**
+ * Assigns default values to generated tags by helpers
+ *
+ * //Assigning "peter" to "name" component
+ * Phalcon\Tag::setDefaults(array("name" => "peter"));
+ * //Later in the view
+ * echo Phalcon\Tag::textField("name"); //Will have the value "peter" by default
+ *
+ *
+ * @param array $values
+ * @param bool $merge
+ */
+ public static function setDefaults($values, $merge = false) {}
+
+ /**
+ * Alias of Phalcon\Tag::setDefault
+ *
+ * @param string $id
+ * @param string $value
+ */
+ public static function displayTo($id, $value) {}
+
+ /**
+ * Check if a helper has a default value set using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @return boolean
+ */
+ public static function hasValue($name) {}
+
+ /**
+ * Every helper calls this function to check whether a component has a predefined
+ * value using Phalcon\Tag::setDefault or value from _POST
+ *
+ * @param string $name
+ * @param array $params
+ * @return mixed
+ */
+ public static function getValue($name, $params = null) {}
+
+ /**
+ * Resets the request and internal values to avoid those fields will have any default value
+ */
+ public static function resetInput() {}
+
+ /**
+ * Builds a HTML A tag using framework conventions
+ *
+ * echo Phalcon\Tag::linkTo("signup/register", "Register Here!");
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!"));
+ * echo Phalcon\Tag::linkTo(array("signup/register", "Register Here!", "class" => "btn-primary"));
+ * echo Phalcon\Tag::linkTo("http://phalconphp.com/", "Phalcon", FALSE);
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", FALSE));
+ * echo Phalcon\Tag::linkTo(array("http://phalconphp.com/", "Phalcon Home", "local" =>FALSE));
+ *
+ *
+ * @param array|string $parameters
+ * @param string $text
+ * @param boolean $local
+ * @return string
+ */
+ public static function linkTo($parameters, $text = null, $local = true) {}
+
+ /**
+ * Builds generic INPUT tags
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @param bool $asValue
+ * @param $boolean asValue
+ * @return string
+ */
+ static protected final function _inputField($type, $parameters, $asValue = false) {}
+
+ /**
+ * Builds INPUT tags that implements the checked attribute
+ *
+ * @param array parameters
+ * @return string
+ * @param string $type
+ * @param mixed $parameters
+ * @return string
+ */
+ static protected final function _inputFieldChecked($type, $parameters) {}
+
+ /**
+ * Builds a HTML input[type="color"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function colorField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="text"] tag
+ *
+ * echo Phalcon\Tag::textField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="number"] tag
+ *
+ * echo Phalcon\Tag::numericField(array("price", "min" => "1", "max" => "5"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function numericField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="range"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function rangeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="email"] tag
+ *
+ * echo Phalcon\Tag::emailField("email");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function emailField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="date"] tag
+ *
+ * echo Phalcon\Tag::dateField(array("born", "value" => "14-12-1980"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function dateField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="datetime-local"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function dateTimeLocalField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="month"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function monthField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="time"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function timeField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="week"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function weekField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="password"] tag
+ *
+ * echo Phalcon\Tag::passwordField(array("name", "size" => 30));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function passwordField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="hidden"] tag
+ *
+ * echo Phalcon\Tag::hiddenField(array("name", "value" => "mike"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function hiddenField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="file"] tag
+ *
+ * echo Phalcon\Tag::fileField("file");
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function fileField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="search"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function searchField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="tel"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function telField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="url"] tag
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function urlField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="check"] tag
+ *
+ * echo Phalcon\Tag::checkField(array("terms", "value" => "Y"));
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function checkField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="radio"] tag
+ *
+ * echo Phalcon\Tag::radioField(array("weather", "value" => "hot"))
+ *
+ * Volt syntax:
+ *
+ * {{ radio_field("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function radioField($parameters) {}
+
+ /**
+ * Builds a HTML input[type="image"] tag
+ *
+ * echo Phalcon\Tag::imageInput(array("src" => "/img/button.png"));
+ *
+ * Volt syntax:
+ *
+ * {{ image_input("src": "/img/button.png") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function imageInput($parameters) {}
+
+ /**
+ * Builds a HTML input[type="submit"] tag
+ *
+ * echo Phalcon\Tag::submitButton("Save")
+ *
+ * Volt syntax:
+ *
+ * {{ submit_button("Save") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function submitButton($parameters) {}
+
+ /**
+ * Builds a HTML SELECT tag using a PHP array for options
+ *
+ * echo Phalcon\Tag::selectStatic("status", array("A" => "Active", "I" => "Inactive"))
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function selectStatic($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML SELECT tag using a Phalcon\Mvc\Model resultset as options
+ *
+ * echo Phalcon\Tag::select(array(
+ * "robotId",
+ * Robots::find("type = "mechanical""),
+ * "using" => array("id", "name")
+ * ));
+ *
+ * Volt syntax:
+ *
+ * {{ select("robotId", robots, "using": ["id", "name"]) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param array $data
+ * @return string
+ */
+ public static function select($parameters, $data = null) {}
+
+ /**
+ * Builds a HTML TEXTAREA tag
+ *
+ * echo Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4))
+ *
+ * Volt syntax:
+ *
+ * {{ text_area("comments", "cols": 10, "rows": 4) }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @return string
+ */
+ public static function textArea($parameters) {}
+
+ /**
+ * Builds a HTML FORM tag
+ *
+ * echo Phalcon\Tag::form("posts/save");
+ * echo Phalcon\Tag::form(array("posts/save", "method" => "post"));
+ *
+ * Volt syntax:
+ *
+ * {{ form("posts/save") }}
+ * {{ form("posts/save", "method": "post") }}
+ *
+ *
+ * @param array $parameters
+ * @return string
+ */
+ public static function form($parameters) {}
+
+ /**
+ * Builds a HTML close FORM tag
+ *
+ * @return string
+ */
+ public static function endForm() {}
+
+ /**
+ * Set the title of view content
+ *
+ * Phalcon\Tag::setTitle("Welcome to my Page");
+ *
+ *
+ * @param string $title
+ */
+ public static function setTitle($title) {}
+
+ /**
+ * Set the title separator of view content
+ *
+ * Phalcon\Tag::setTitleSeparator("-");
+ *
+ *
+ * @param string $titleSeparator
+ */
+ public static function setTitleSeparator($titleSeparator) {}
+
+ /**
+ * Appends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function appendTitle($title) {}
+
+ /**
+ * Prepends a text to current document title
+ *
+ * @param string $title
+ */
+ public static function prependTitle($title) {}
+
+ /**
+ * Gets the current document title
+ *
+ * echo Phalcon\Tag::getTitle();
+ *
+ *
+ * {{ get_title() }}
+ *
+ *
+ * @param bool $tags
+ * @return string
+ */
+ public static function getTitle($tags = true) {}
+
+ /**
+ * Gets the current document title separator
+ *
+ * echo Phalcon\Tag::getTitleSeparator();
+ *
+ *
+ * {{ get_title_separator() }}
+ *
+ *
+ * @return string
+ */
+ public static function getTitleSeparator() {}
+
+ /**
+ * Builds a LINK[rel="stylesheet"] tag
+ *
+ * echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
+ * echo Phalcon\Tag::stylesheetLink("css/style.css");
+ *
+ * Volt Syntax:
+ *
+ * {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }}
+ * {{ stylesheet_link("css/style.css") }}
+ *
+ *
+ * @param array parameters
+ * @return string
+ * @param mixed $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function stylesheetLink($parameters = null, $local = true) {}
+
+ /**
+ * Builds a SCRIPT[type="javascript"] tag
+ *
+ * echo Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false);
+ * echo Phalcon\Tag::javascriptInclude("javascript/jquery.js");
+ *
+ * Volt syntax:
+ *
+ * {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false) }}
+ * {{ javascript_include("javascript/jquery.js") }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function javascriptInclude($parameters = null, $local = true) {}
+
+ /**
+ * Builds HTML IMG tags
+ *
+ * echo Phalcon\Tag::image("img/bg.png");
+ * echo Phalcon\Tag::image(array("img/photo.jpg", "alt" => "Some Photo"));
+ *
+ * Volt Syntax:
+ *
+ * {{ image("img/bg.png") }}
+ * {{ image("img/photo.jpg", "alt": "Some Photo") }}
+ * {{ image("http://static.mywebsite.com/img/bg.png", false) }}
+ *
+ *
+ * @param array $parameters
+ * @param boolean $local
+ * @return string
+ */
+ public static function image($parameters = null, $local = true) {}
+
+ /**
+ * Converts texts into URL-friendly titles
+ *
+ * echo Phalcon\Tag::friendlyTitle("These are big important news", "-")
+ *
+ *
+ * @param string $text
+ * @param string $separator
+ * @param boolean $lowercase
+ * @param mixed $replace
+ * @return string
+ */
+ public static function friendlyTitle($text, $separator = "-", $lowercase = true, $replace = null) {}
+
+ /**
+ * Set the document type of content
+ *
+ * @param int $doctype
+ */
+ public static function setDocType($doctype) {}
+
+ /**
+ * Get the document type declaration of content
+ *
+ * @return string
+ */
+ public static function getDocType() {}
+
+ /**
+ * Builds a HTML tag
+ *
+ * echo Phalcon\Tag::tagHtml(name, parameters, selfClose, onlyStart, eol);
+ *
+ *
+ * @param string $tagName
+ * @param array $parameters
+ * @param boolean $selfClose
+ * @param boolean $onlyStart
+ * @param boolean $useEol
+ * @return string
+ */
+ public static function tagHtml($tagName, $parameters = null, $selfClose = false, $onlyStart = false, $useEol = false) {}
+
+ /**
+ * Builds a HTML tag closing tag
+ *
+ * echo Phalcon\Tag::tagHtmlClose("script", true)
+ *
+ *
+ * @param string $tagName
+ * @param bool $useEol
+ * @return string
+ */
+ public static function tagHtmlClose($tagName, $useEol = false) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Text.php b/ide/2.0.6/Phalcon/Text.php
new file mode 100644
index 000000000..34ee9fb59
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Text.php
@@ -0,0 +1,171 @@
+
+ * echo Phalcon\Text::camelize('coco_bongo'); //CocoBongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function camelize($str) {}
+
+ /**
+ * Uncamelize strings which are camelized
+ *
+ * echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function uncamelize($str) {}
+
+ /**
+ * Adds a number to a string or increment that number if it already is defined
+ *
+ * echo Phalcon\Text::increment("a"); // "a_1"
+ * echo Phalcon\Text::increment("a_1"); // "a_2"
+ *
+ *
+ * @param string $str
+ * @param string $separator
+ * @return string
+ */
+ public static function increment($str, $separator = "_") {}
+
+ /**
+ * Generates a random string based on the given type. Type is one of the RANDOM_* constants
+ *
+ * echo Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz"
+ *
+ *
+ * @param int $type
+ * @param long $length
+ * @return string
+ */
+ public static function random($type = 0, $length = 8) {}
+
+ /**
+ * Check if a string starts with a given string
+ *
+ * echo Phalcon\Text::startsWith("Hello", "He"); // true
+ * echo Phalcon\Text::startsWith("Hello", "he", false); // false
+ * echo Phalcon\Text::startsWith("Hello", "he"); // true
+ *
+ *
+ * @param string $str
+ * @param string $start
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function startsWith($str, $start, $ignoreCase = true) {}
+
+ /**
+ * Check if a string ends with a given string
+ *
+ * echo Phalcon\Text::endsWith("Hello", "llo"); // true
+ * echo Phalcon\Text::endsWith("Hello", "LLO", false); // false
+ * echo Phalcon\Text::endsWith("Hello", "LLO"); // true
+ *
+ *
+ * @param string $str
+ * @param string $end
+ * @param bool $ignoreCase
+ * @return bool
+ */
+ public static function endsWith($str, $end, $ignoreCase = true) {}
+
+ /**
+ * Lowercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::lower("HELLO"); // hello
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function lower($str, $encoding = "UTF-8") {}
+
+ /**
+ * Uppercases a string, this function makes use of the mbstring extension if available
+ *
+ * echo Phalcon\Text::upper("hello"); // HELLO
+ *
+ *
+ * @param string $str
+ * @param string $encoding
+ * @return string
+ */
+ public static function upper($str, $encoding = "UTF-8") {}
+
+ /**
+ * Reduces multiple slashes in a string to single slashes
+ *
+ * echo Phalcon\Text::reduceSlashes("foo//bar/baz"); // foo/bar/baz
+ * echo Phalcon\Text::reduceSlashes("http://foo.bar///baz/buz"); // http://foo.bar/baz/buz
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public static function reduceSlashes($str) {}
+
+ /**
+ * Concatenates strings using the separator only once without duplication in places concatenation
+ *
+ * $str = Phalcon\Text::concat("/", "/tmp/", "/folder_1/", "/folder_2", "folder_3/");
+ * echo $str; // /tmp/folder_1/folder_2/folder_3/
+ *
+ *
+ * @param string $separator
+ * @param string $a
+ * @param string $b
+ * @param string $...N
+ * @return string
+ */
+ public static function concat() {}
+
+ /**
+ * Generates random text in accordance with the template
+ *
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon
+ * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob
+ *
+ *
+ * @param string $text
+ * @param string $leftDelimiter
+ * @param string $rightDelimiter
+ * @param string $separator
+ * @return string
+ */
+ public static function dynamic($text, $leftDelimiter = "{", $rightDelimiter = "}", $separator = "|") {}
+
+}
diff --git a/ide/2.0.6/Phalcon/Translate.php b/ide/2.0.6/Phalcon/Translate.php
new file mode 100644
index 000000000..e0cf39581
--- /dev/null
+++ b/ide/2.0.6/Phalcon/Translate.php
@@ -0,0 +1,13 @@
+
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ */
+ const VERSION_MAJOR = 0;
+
+ /**
+ * The constant referencing the major version. Returns 1
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MEDIUM);
+ *
+ */
+ const VERSION_MEDIUM = 1;
+
+ /**
+ * The constant referencing the major version. Returns 2
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MINOR);
+ *
+ */
+ const VERSION_MINOR = 2;
+
+ /**
+ * The constant referencing the major version. Returns 3
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL);
+ *
+ */
+ const VERSION_SPECIAL = 3;
+
+ /**
+ * The constant referencing the major version. Returns 4
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_SPECIAL_NUMBER);
+ *
+ */
+ const VERSION_SPECIAL_NUMBER = 4;
+
+
+ /**
+ * Area where the version number is set. The format is as follows:
+ * ABBCCDE
+ * A - Major version
+ * B - Med version (two digits)
+ * C - Min version (two digits)
+ * D - Special release: 1 = Alpha, 2 = Beta, 3 = RC, 4 = Stable
+ * E - Special release version i.e. RC1, Beta2 etc.
+ *
+ * @return array
+ */
+ protected static function _getVersion() {}
+
+ /**
+ * Translates a number to a special release
+ * If Special release = 1 this function will return ALPHA
+ *
+ * @param int $special
+ * @return string
+ */
+ protected final static function _getSpecial($special) {}
+
+ /**
+ * Returns the active version (string)
+ *
+ * echo Phalcon\Version::get();
+ *
+ *
+ * @return string
+ */
+ public static function get() {}
+
+ /**
+ * Returns the numeric active version
+ *
+ * echo Phalcon\Version::getId();
+ *
+ *
+ * @return string
+ */
+ public static function getId() {}
+
+ /**
+ * Returns a specific part of the version. If the wrong parameter is passed
+ * it will return the full version
+ *
+ * echo Phalcon\Version::getPart(Phalcon\Version::VERSION_MAJOR);
+ *
+ *
+ * @param int $part
+ * @return string
+ */
+ public static function getPart($part) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/acl/Adapter.php b/ide/2.0.6/Phalcon/acl/Adapter.php
new file mode 100644
index 000000000..d261e1917
--- /dev/null
+++ b/ide/2.0.6/Phalcon/acl/Adapter.php
@@ -0,0 +1,103 @@
+
+ * $acl = new \Phalcon\Acl\Adapter\Memory();
+ * $acl->setDefaultAction(Phalcon\Acl::DENY);
+ * //Register roles
+ * $roles = array(
+ * 'users' => new \Phalcon\Acl\Role('Users'),
+ * 'guests' => new \Phalcon\Acl\Role('Guests')
+ * );
+ * foreach ($roles as $role) {
+ * $acl->addRole($role);
+ * }
+ * //Private area resources
+ * $privateResources = array(
+ * 'companies' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'products' => array('index', 'search', 'new', 'edit', 'save', 'create', 'delete'),
+ * 'invoices' => array('index', 'profile')
+ * );
+ * foreach ($privateResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Public area resources
+ * $publicResources = array(
+ * 'index' => array('index'),
+ * 'about' => array('index'),
+ * 'session' => array('index', 'register', 'start', 'end'),
+ * 'contact' => array('index', 'send')
+ * );
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->addResource(new Phalcon\Acl\Resource($resource), $actions);
+ * }
+ * //Grant access to public areas to both users and guests
+ * foreach ($roles as $role){
+ * foreach ($publicResources as $resource => $actions) {
+ * $acl->allow($role->getName(), $resource, '*');
+ * }
+ * }
+ * //Grant access to private area to role Users
+ * foreach ($privateResources as $resource => $actions) {
+ * foreach ($actions as $action) {
+ * $acl->allow('Users', $resource, $action);
+ * }
+ * }
+ *
+ */
+class Memory extends \Phalcon\Acl\Adapter
+{
+ /**
+ * Roles Names
+ *
+ * @var mixed
+ */
+ protected $_rolesNames;
+
+ /**
+ * Roles
+ *
+ * @var mixed
+ */
+ protected $_roles;
+
+ /**
+ * Resource Names
+ *
+ * @var mixed
+ */
+ protected $_resourcesNames;
+
+ /**
+ * Resources
+ *
+ * @var mixed
+ */
+ protected $_resources;
+
+ /**
+ * Access
+ *
+ * @var mixed
+ */
+ protected $_access;
+
+ /**
+ * Role Inherits
+ *
+ * @var mixed
+ */
+ protected $_roleInherits;
+
+ /**
+ * Access List
+ *
+ * @var mixed
+ */
+ protected $_accessList;
+
+
+ /**
+ * Phalcon\Acl\Adapter\Memory constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Adds a role to the ACL list. Second parameter allows inheriting access data from other existing role
+ * Example:
+ *
+ * $acl->addRole(new Phalcon\Acl\Role('administrator'), 'consultant');
+ * $acl->addRole('administrator', 'consultant');
+ *
+ *
+ * @param mixed $role
+ * @param array|string $accessInherits
+ * @return bool
+ */
+ public function addRole($role, $accessInherits = null) {}
+
+ /**
+ * Do a role inherit from another existing role
+ *
+ * @param string $roleName
+ * @param mixed $roleToInherit
+ * @return bool
+ */
+ public function addInherit($roleName, $roleToInherit) {}
+
+ /**
+ * Check whether role exist in the roles list
+ *
+ * @param string $roleName
+ * @return bool
+ */
+ public function isRole($roleName) {}
+
+ /**
+ * Check whether resource exist in the resources list
+ *
+ * @param string $resourceName
+ * @return bool
+ */
+ public function isResource($resourceName) {}
+
+ /**
+ * Adds a resource to the ACL list
+ * Access names can be a particular action, by example
+ * search, update, delete, etc or a list of them
+ * Example:
+ *
+ * //Add a resource to the the list allowing access to an action
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), 'search');
+ * $acl->addResource('customers', 'search');
+ * //Add a resource with an access list
+ * $acl->addResource(new Phalcon\Acl\Resource('customers'), array('create', 'search'));
+ * $acl->addResource('customers', array('create', 'search'));
+ *
+ *
+ * @param \Phalcon\Acl\Resource|string $resourceValue
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResource($resourceValue, $accessList) {}
+
+ /**
+ * Adds access to resources
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ * @return bool
+ */
+ public function addResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Removes an access from a resource
+ *
+ * @param string $resourceName
+ * @param array|string $accessList
+ */
+ public function dropResourceAccess($resourceName, $accessList) {}
+
+ /**
+ * Checks if a role has access to a resource
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ * @param mixed $action
+ */
+ protected function _allowOrDeny($roleName, $resourceName, $access, $action) {}
+
+ /**
+ * Allow access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Allow access to guests to search on customers
+ * $acl->allow('guests', 'customers', 'search');
+ * //Allow access to guests to search or create on customers
+ * $acl->allow('guests', 'customers', array('search', 'create'));
+ * //Allow access to any role to browse on products
+ * $acl->allow('*', 'products', 'browse');
+ * //Allow access to any role to browse on any resource
+ * $acl->allow('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function allow($roleName, $resourceName, $access) {}
+
+ /**
+ * Deny access to a role on a resource
+ * You can use '*' as wildcard
+ * Example:
+ *
+ * //Deny access to guests to search on customers
+ * $acl->deny('guests', 'customers', 'search');
+ * //Deny access to guests to search or create on customers
+ * $acl->deny('guests', 'customers', array('search', 'create'));
+ * //Deny access to any role to browse on products
+ * $acl->deny('*', 'products', 'browse');
+ * //Deny access to any role to browse on any resource
+ * $acl->deny('*', '*', 'browse');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param mixed $access
+ */
+ public function deny($roleName, $resourceName, $access) {}
+
+ /**
+ * Check whether a role is allowed to access an action from a resource
+ *
+ * //Does andres have access to the customers resource to create?
+ * $acl->isAllowed('andres', 'Products', 'create');
+ * //Do guests have access to any resource to edit?
+ * $acl->isAllowed('guests', '*', 'edit');
+ *
+ *
+ * @param string $roleName
+ * @param string $resourceName
+ * @param string $access
+ * @return bool
+ */
+ public function isAllowed($roleName, $resourceName, $access) {}
+
+ /**
+ * Return an array with every role registered in the list
+ *
+ * @return \Phalcon\Acl\Role
+ */
+ public function getRoles() {}
+
+ /**
+ * Return an array with every resource registered in the list
+ *
+ * @return \Phalcon\Acl\Resource
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/annotations/Adapter.php b/ide/2.0.6/Phalcon/annotations/Adapter.php
new file mode 100644
index 000000000..19b67c0aa
--- /dev/null
+++ b/ide/2.0.6/Phalcon/annotations/Adapter.php
@@ -0,0 +1,74 @@
+
+ * //Traverse annotations
+ * foreach ($classAnnotations as $annotation) {
+ * echo 'Name=', $annotation->getName(), PHP_EOL;
+ * }
+ * //Check if the annotations has a specific
+ * var_dump($classAnnotations->has('Cacheable'));
+ * //Get an specific annotation in the collection
+ * $annotation = $classAnnotations->get('Cacheable');
+ *
+ */
+class Collection implements \Iterator, \Countable
+{
+
+ protected $_position = 0;
+
+
+ protected $_annotations;
+
+
+ /**
+ * Phalcon\Annotations\Collection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the number of annotations in the collection
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current annotation in the iterator
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current annotation in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Returns the internal annotations as an array
+ *
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAnnotations() {}
+
+ /**
+ * Returns the first annotation that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function get($name) {}
+
+ /**
+ * Returns all the annotations that match a name
+ *
+ * @param string $name
+ * @return \Phalcon\Annotations\Annotation
+ */
+ public function getAll($name) {}
+
+ /**
+ * Check if an annotation exists in a collection
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/annotations/Exception.php b/ide/2.0.6/Phalcon/annotations/Exception.php
new file mode 100644
index 000000000..973db2530
--- /dev/null
+++ b/ide/2.0.6/Phalcon/annotations/Exception.php
@@ -0,0 +1,9 @@
+
+ * use Phalcon\Annotations\Reader;
+ * use Phalcon\Annotations\Reflection;
+ * // Parse the annotations in a class
+ * $reader = new Reader();
+ * $parsing = reader->parse('MyComponent');
+ * // Create the reflection
+ * $reflection = new Reflection($parsing);
+ * // Get the annotations in the class docblock
+ * $classAnnotations = reflection->getClassAnnotations();
+ *
+ */
+class Reflection
+{
+
+ protected $_reflectionData;
+
+
+ protected $_classAnnotations;
+
+
+ protected $_methodAnnotations;
+
+
+ protected $_propertyAnnotations;
+
+
+ /**
+ * Phalcon\Annotations\Reflection constructor
+ *
+ * @param array $reflectionData
+ */
+ public function __construct($reflectionData = null) {}
+
+ /**
+ * Returns the annotations found in the class docblock
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getClassAnnotations() {}
+
+ /**
+ * Returns the annotations found in the methods' docblocks
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getMethodsAnnotations() {}
+
+ /**
+ * Returns the annotations found in the properties' docblocks
+ *
+ * @return bool|\Phalcon\Annotations\Collection
+ */
+ public function getPropertiesAnnotations() {}
+
+ /**
+ * Returns the raw parsing intermediate definitions used to construct the reflection
+ *
+ * @return array
+ */
+ public function getReflectionData() {}
+
+ /**
+ * Restores the state of a Phalcon\Annotations\Reflection variable export
+ *
+ * @param mixed $data
+ * @return array
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/annotations/adapter/Apc.php b/ide/2.0.6/Phalcon/annotations/adapter/Apc.php
new file mode 100644
index 000000000..822c0c8a8
--- /dev/null
+++ b/ide/2.0.6/Phalcon/annotations/adapter/Apc.php
@@ -0,0 +1,44 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Apc();
+ *
+ */
+class Apc extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from APC
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/annotations/adapter/Files.php b/ide/2.0.6/Phalcon/annotations/adapter/Files.php
new file mode 100644
index 000000000..9115c2b35
--- /dev/null
+++ b/ide/2.0.6/Phalcon/annotations/adapter/Files.php
@@ -0,0 +1,43 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Files(array(
+ * 'annotationsDir' => 'app/cache/annotations/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ protected $_annotationsDir = "./";
+
+
+ /**
+ * Phalcon\Annotations\Adapter\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads parsed annotations from files
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to files
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/annotations/adapter/Memory.php b/ide/2.0.6/Phalcon/annotations/adapter/Memory.php
new file mode 100644
index 000000000..84ad80c8c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/annotations/adapter/Memory.php
@@ -0,0 +1,35 @@
+
+ * $annotations = new \Phalcon\Annotations\Adapter\Xcache();
+ *
+ */
+class Xcache extends \Phalcon\Annotations\Adapter implements \Phalcon\Annotations\AdapterInterface
+{
+
+ /**
+ * Reads parsed annotations from XCache
+ *
+ * @param string $key
+ * @return \Phalcon\Annotations\Reflection
+ */
+ public function read($key) {}
+
+ /**
+ * Writes parsed annotations to XCache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, \Phalcon\Annotations\Reflection $data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/assets/Collection.php b/ide/2.0.6/Phalcon/assets/Collection.php
new file mode 100644
index 000000000..5895735fb
--- /dev/null
+++ b/ide/2.0.6/Phalcon/assets/Collection.php
@@ -0,0 +1,271 @@
+
+ * $inline = new \Phalcon\Assets\Inline('js', 'alert("hello world");');
+ *
+ */
+class Inline
+{
+
+ protected $_type;
+
+
+ protected $_content;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+
+ public function getType() {}
+
+
+ public function getContent() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+ /**
+ * Phalcon\Assets\Inline constructor
+ *
+ * @param string $type
+ * @param string $content
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $content, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the inline's type
+ *
+ * @param string $type
+ * @return Inline
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Inline
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Inline
+ */
+ public function setAttributes($attributes) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/assets/Manager.php b/ide/2.0.6/Phalcon/assets/Manager.php
new file mode 100644
index 000000000..b2c0e7625
--- /dev/null
+++ b/ide/2.0.6/Phalcon/assets/Manager.php
@@ -0,0 +1,242 @@
+
+ * $assets->addCss('css/bootstrap.css');
+ * $assets->addCss('http://bootstrap.my-cdn.com/style.css', false);
+ *
+ *
+ * @param string $path
+ * @param mixed $local
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addCss($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline Css to the 'css' collection
+ *
+ * @param string $content
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addInlineCss($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a javascript resource to the 'js' collection
+ *
+ * $assets->addJs('scripts/jquery.js');
+ * $assets->addJs('http://jquery.my-cdn.com/jquery.js', false);
+ *
+ *
+ * @param string $path
+ * @param mixed $local
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addJs($path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a inline javascript to the 'js' collection
+ *
+ * @param string $content
+ * @param mixed $filter
+ * @param mixed $attributes
+ * @return Manager
+ */
+ public function addInlineJs($content, $filter = true, $attributes = null) {}
+
+ /**
+ * Adds a resource by its type
+ *
+ * $assets->addResourceByType('css', new \Phalcon\Assets\Resource\Css('css/style.css'));
+ *
+ *
+ * @param string $type
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResourceByType($type, \Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a inline code by its type
+ *
+ * @param string $type
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCodeByType($type, Inline $code) {}
+
+ /**
+ * Adds a raw resource to the manager
+ *
+ * $assets->addResource(new Phalcon\Assets\Resource('css', 'css/style.css'));
+ *
+ *
+ * @param mixed $resource
+ * @return Manager
+ */
+ public function addResource(\Phalcon\Assets\Resource $resource) {}
+
+ /**
+ * Adds a raw inline code to the manager
+ *
+ * @param mixed $code
+ * @return Manager
+ */
+ public function addInlineCode(Inline $code) {}
+
+ /**
+ * Sets a collection in the Assets Manager
+ *
+ * $assets->set('js', $collection);
+ *
+ *
+ * @param string $id
+ * @param mixed $collection
+ * @return Manager
+ */
+ public function set($id, \Phalcon\Assets\Collection $collection) {}
+
+ /**
+ * Returns a collection by its id
+ *
+ * $scripts = $assets->get('js');
+ *
+ *
+ * @param string $id
+ * @return \Phalcon\Assets\Collection
+ */
+ public function get($id) {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getCss() {}
+
+ /**
+ * Returns the CSS collection of assets
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getJs() {}
+
+ /**
+ * Creates/Returns a collection of resources
+ *
+ * @param string $name
+ * @return \Phalcon\Assets\Collection
+ */
+ public function collection($name) {}
+
+ /**
+ * Traverses a collection calling the callback to generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param callback $callback
+ * @param string $type
+ */
+ public function output(\Phalcon\Assets\Collection $collection, $callback, $type) {}
+
+ /**
+ * Traverses a collection and generate its HTML
+ *
+ * @param \Phalcon\Assets\Collection $collection
+ * @param string $type
+ */
+ public function outputInline(\Phalcon\Assets\Collection $collection, $type) {}
+
+ /**
+ * Prints the HTML for CSS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline CSS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineCss($collectionName = null) {}
+
+ /**
+ * Prints the HTML for JS resources
+ *
+ * @param string $collectionName
+ */
+ public function outputJs($collectionName = null) {}
+
+ /**
+ * Prints the HTML for inline JS
+ *
+ * @param string $collectionName
+ */
+ public function outputInlineJs($collectionName = null) {}
+
+ /**
+ * Returns existing collections in the manager
+ *
+ * @return \Phalcon\Assets\Collection
+ */
+ public function getCollections() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/assets/Resource.php b/ide/2.0.6/Phalcon/assets/Resource.php
new file mode 100644
index 000000000..e2013640d
--- /dev/null
+++ b/ide/2.0.6/Phalcon/assets/Resource.php
@@ -0,0 +1,170 @@
+
+ * $resource = new \Phalcon\Assets\Resource('js', 'javascripts/jquery.js');
+ *
+ */
+class Resource
+{
+
+ protected $_type;
+
+
+ protected $_path;
+
+
+ protected $_local;
+
+
+ protected $_filter;
+
+
+ protected $_attributes;
+
+
+ protected $_sourcePath;
+
+
+ protected $_targetPath;
+
+
+ protected $_targetUri;
+
+
+
+ public function getType() {}
+
+
+ public function getPath() {}
+
+
+ public function getLocal() {}
+
+
+ public function getFilter() {}
+
+
+ public function getAttributes() {}
+
+
+ public function getSourcePath() {}
+
+
+ public function getTargetPath() {}
+
+
+ public function getTargetUri() {}
+
+ /**
+ * Phalcon\Assets\Resource constructor
+ *
+ * @param string $type
+ * @param string $path
+ * @param boolean $local
+ * @param boolean $filter
+ * @param array $attributes
+ */
+ public function __construct($type, $path, $local = true, $filter = true, $attributes = null) {}
+
+ /**
+ * Sets the resource's type
+ *
+ * @param string $type
+ * @return Resource
+ */
+ public function setType($type) {}
+
+ /**
+ * Sets the resource's path
+ *
+ * @param string $path
+ * @return Resource
+ */
+ public function setPath($path) {}
+
+ /**
+ * Sets if the resource is local or external
+ *
+ * @param bool $local
+ * @return Resource
+ */
+ public function setLocal($local) {}
+
+ /**
+ * Sets if the resource must be filtered or not
+ *
+ * @param bool $filter
+ * @return Resource
+ */
+ public function setFilter($filter) {}
+
+ /**
+ * Sets extra HTML attributes
+ *
+ * @param array $attributes
+ * @return Resource
+ */
+ public function setAttributes($attributes) {}
+
+ /**
+ * Sets a target uri for the generated HTML
+ *
+ * @param string $targetUri
+ * @return Resource
+ */
+ public function setTargetUri($targetUri) {}
+
+ /**
+ * Sets the resource's source path
+ *
+ * @param string $sourcePath
+ * @return Resource
+ */
+ public function setSourcePath($sourcePath) {}
+
+ /**
+ * Sets the resource's target path
+ *
+ * @param string $targetPath
+ * @return Resource
+ */
+ public function setTargetPath($targetPath) {}
+
+ /**
+ * Returns the content of the resource as an string
+ * Optionally a base path where the resource is located can be set
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getContent($basePath = null) {}
+
+ /**
+ * Returns the real target uri for the generated HTML
+ *
+ * @return string
+ */
+ public function getRealTargetUri() {}
+
+ /**
+ * Returns the complete location where the resource is located
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealSourcePath($basePath = null) {}
+
+ /**
+ * Returns the complete location where the resource must be written
+ *
+ * @param string $basePath
+ * @return string
+ */
+ public function getRealTargetPath($basePath = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/assets/filters/Cssmin.php b/ide/2.0.6/Phalcon/assets/filters/Cssmin.php
new file mode 100644
index 000000000..7071441f5
--- /dev/null
+++ b/ide/2.0.6/Phalcon/assets/filters/Cssmin.php
@@ -0,0 +1,22 @@
+
+ * use Phalcon\Cache\Frontend\Data as DataFrontend,
+ * Phalcon\Cache\Multiple,
+ * Phalcon\Cache\Backend\Apc as ApcCache,
+ * Phalcon\Cache\Backend\Memcache as MemcacheCache,
+ * Phalcon\Cache\Backend\File as FileCache;
+ * $ultraFastFrontend = new DataFrontend(array(
+ * "lifetime" => 3600
+ * ));
+ * $fastFrontend = new DataFrontend(array(
+ * "lifetime" => 86400
+ * ));
+ * $slowFrontend = new DataFrontend(array(
+ * "lifetime" => 604800
+ * ));
+ * //Backends are registered from the fastest to the slower
+ * $cache = new Multiple(array(
+ * new ApcCache($ultraFastFrontend, array(
+ * "prefix" => 'cache',
+ * )),
+ * new MemcacheCache($fastFrontend, array(
+ * "prefix" => 'cache',
+ * "host" => "localhost",
+ * "port" => "11211"
+ * )),
+ * new FileCache($slowFrontend, array(
+ * "prefix" => 'cache',
+ * "cacheDir" => "../app/cache/"
+ * ))
+ * ));
+ * //Save, saves in every backend
+ * $cache->save('my-key', $data);
+ *
+ */
+class Multiple
+{
+
+ protected $_backends;
+
+
+ /**
+ * Phalcon\Cache\Multiple constructor
+ *
+ * @param Phalcon\Cache\BackendInterface[] backends
+ * @param mixed $backends
+ */
+ public function __construct($backends = null) {}
+
+ /**
+ * Adds a backend
+ *
+ * @param mixed $backend
+ * @return Multiple
+ */
+ public function push(\Phalcon\Cache\BackendInterface $backend) {}
+
+ /**
+ * Returns a cached content reading the internal backends
+ *
+ * @param mixed $keyName
+ * @param long $lifetime
+ * @param $string|int keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Starts every backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ */
+ public function start($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into all backends and stops the frontend
+ *
+ * @param string $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = null) {}
+
+ /**
+ * Deletes a value from each backend
+ *
+ * @param string|int $keyName
+ * @return boolean
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Checks if cache exists in at least one backend
+ *
+ * @param string|int $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/cache/backend/Apc.php b/ide/2.0.6/Phalcon/cache/backend/Apc.php
new file mode 100644
index 000000000..8e6f53d83
--- /dev/null
+++ b/ide/2.0.6/Phalcon/cache/backend/Apc.php
@@ -0,0 +1,95 @@
+
+ * //Cache data for 2 days
+ * $frontCache = new \Phalcon\Cache\Frontend\Data(array(
+ * 'lifetime' => 172800
+ * ));
+ * $cache = new \Phalcon\Cache\Backend\Apc($frontCache, array(
+ * 'prefix' => 'app-data'
+ * ));
+ * //Cache arbitrary data
+ * $cache->save('my-data', array(1, 2, 3, 4, 5));
+ * //Get data
+ * $data = $cache->get('my-data');
+ *
+ */
+class Apc extends \Phalcon\Cache\Backend implements \Phalcon\Cache\BackendInterface
+{
+
+ /**
+ * Returns a cached content
+ *
+ * @param string $keyName
+ * @param long $lifetime
+ * @param $string|long keyName
+ * @return mixed
+ */
+ public function get($keyName, $lifetime = null) {}
+
+ /**
+ * Stores cached content into the APC backend and stops the frontend
+ *
+ * @param string|long $keyName
+ * @param string $content
+ * @param long $lifetime
+ * @param boolean $stopBuffer
+ */
+ public function save($keyName = null, $content = null, $lifetime = null, $stopBuffer = true) {}
+
+ /**
+ * Increment of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function increment($keyName = null, $value = 1) {}
+
+ /**
+ * Decrement of a given key, by number $value
+ *
+ * @param string $keyName
+ * @param long $value
+ * @return mixed
+ */
+ public function decrement($keyName = null, $value = 1) {}
+
+ /**
+ * Deletes a value from the cache by its key
+ *
+ * @param string $keyName
+ * @return bool
+ */
+ public function delete($keyName) {}
+
+ /**
+ * Query the existing cached keys
+ *
+ * @param string $prefix
+ * @return array
+ */
+ public function queryKeys($prefix = null) {}
+
+ /**
+ * Checks if cache exists and it hasn't expired
+ *
+ * @param string|long $keyName
+ * @param long $lifetime
+ * @return boolean
+ */
+ public function exists($keyName = null, $lifetime = null) {}
+
+ /**
+ * Immediately invalidates all existing items.
+ *
+ * @return bool
+ */
+ public function flush() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/cache/backend/File.php b/ide/2.0.6/Phalcon/cache/backend/File.php
new file mode 100644
index 000000000..44e4a87c0
--- /dev/null
+++ b/ide/2.0.6/Phalcon/cache/backend/File.php
@@ -0,0 +1,135 @@
+
+ * //Cache the file for 2 days
+ * $frontendOptions = array(
+ * 'lifetime' => 172800
+ * );
+ * //Create a output cache
+ * $frontCache = \Phalcon\Cache\Frontend\Output($frontOptions);
+ * //Set the cache directory
+ * $backendOptions = array(
+ * 'cacheDir' => '../app/cache/'
+ * );
+ * //Create the File backend
+ * $cache = new \Phalcon\Cache\Backend\File($frontCache, $backendOptions);
+ * $content = $cache->start('my-cache');
+ * if ($content === null) {
+ * echo '
+ * application->addModules(array(
+ * 'admin' => array(
+ * 'className' => 'Multiple\Admin\Module',
+ * 'path' => '../apps/admin/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ */
+ public function addModules($modules) {}
+
+ /**
+ * Return the modules registered in the console
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Handle the whole command-line tasks
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Set an specific argument
+ *
+ * @param array $arguments
+ * @param bool $str
+ * @param bool $shift
+ * @return Console
+ */
+ public function setArgument($arguments = null, $str = true, $shift = true) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/cli/Dispatcher.php b/ide/2.0.6/Phalcon/cli/Dispatcher.php
new file mode 100644
index 000000000..9af6c4e3f
--- /dev/null
+++ b/ide/2.0.6/Phalcon/cli/Dispatcher.php
@@ -0,0 +1,111 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Cli\Dispatcher();
+ * $dispatcher->setDi(di);
+ * $dispatcher->setTaskName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $handle = dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher
+{
+
+ protected $_handlerSuffix = "Task";
+
+
+ protected $_defaultHandler = "main";
+
+
+ protected $_defaultAction = "main";
+
+
+ protected $_options;
+
+
+ /**
+ * Phalcon\Cli\Dispatcher constructor
+ */
+ public function __construct() {}
+
+ /**
+ * Sets the default task suffix
+ *
+ * @param string $taskSuffix
+ */
+ public function setTaskSuffix($taskSuffix) {}
+
+ /**
+ * Sets the default task name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the task name to be dispatched
+ *
+ * @param string $taskName
+ */
+ public function setTaskName($taskName) {}
+
+ /**
+ * Gets last dispatched task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getLastTask() {}
+
+ /**
+ * Returns the active task in the dispatcher
+ *
+ * @return \Phalcon\Cli\Task
+ */
+ public function getActiveTask() {}
+
+ /**
+ * Set the options to be dispatched
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get dispatched options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/cli/Router.php b/ide/2.0.6/Phalcon/cli/Router.php
new file mode 100644
index 000000000..57c6a3f88
--- /dev/null
+++ b/ide/2.0.6/Phalcon/cli/Router.php
@@ -0,0 +1,211 @@
+Phalcon\Cli\Router is the standard framework router. Routing is the
+ * process of taking a command-line arguments and
+ * decomposing it into parameters to determine which module, task, and
+ * action of that task should receive the request
+ *
+ * $router = new \Phalcon\Cli\Router();
+ * $router->handle(array(
+ * 'module' => 'main',
+ * 'task' => 'videos',
+ * 'action' => 'process'
+ * ));
+ * echo $router->getTaskName();
+ *
+ */
+class Router implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_module;
+
+
+ protected $_task;
+
+
+ protected $_action;
+
+
+ protected $_params;
+
+
+ protected $_defaultModule = null;
+
+
+ protected $_defaultTask = null;
+
+
+ protected $_defaultAction = null;
+
+
+ protected $_defaultParams;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ /**
+ * Phalcon\Cli\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $taskName
+ */
+ public function setDefaultTask($taskName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return Router
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Handles routing information received from command-line arguments
+ *
+ * @param array $arguments
+ */
+ public function handle($arguments = null) {}
+
+ /**
+ * Adds a route to the router
+ *
+ * $router->add('/about', 'About::main');
+ *
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function add($pattern, $paths = null) {}
+
+ /**
+ * Returns proccesed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns proccesed task name
+ *
+ * @return string
+ */
+ public function getTaskName() {}
+
+ /**
+ * Returns proccesed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns proccesed extra params
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param int $id
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Cli\Router\Route
+ */
+ public function getRouteByName($name) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/cli/Task.php b/ide/2.0.6/Phalcon/cli/Task.php
new file mode 100644
index 000000000..5a8d068e5
--- /dev/null
+++ b/ide/2.0.6/Phalcon/cli/Task.php
@@ -0,0 +1,31 @@
+
+ * class HelloTask extends \Phalcon\Cli\Task
+ * {
+ * //This action will be executed by default
+ * public function mainAction()
+ * {
+ * }
+ * public function findAction()
+ * {
+ * }
+ * }
+ *
+ */
+class Task extends \Phalcon\Di\Injectable
+{
+
+ /**
+ * Phalcon\Cli\Task constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/cli/console/Exception.php b/ide/2.0.6/Phalcon/cli/console/Exception.php
new file mode 100644
index 000000000..91718714c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/cli/console/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callback $callback
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return mixed
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param callable $converter
+ * @return \Phalcon\Cli\Router\Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+ /**
+ * Set the routing delimiter
+ *
+ * @param string $delimiter
+ */
+ public static function delimiter($delimiter = null) {}
+
+ /**
+ * Get routing delimiter
+ *
+ * @return string
+ */
+ public static function getDelimiter() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/config/Exception.php b/ide/2.0.6/Phalcon/config/Exception.php
new file mode 100644
index 000000000..a6f27ac66
--- /dev/null
+++ b/ide/2.0.6/Phalcon/config/Exception.php
@@ -0,0 +1,12 @@
+
+ * [database]
+ * adapter = Mysql
+ * host = localhost
+ * username = scott
+ * password = cheetah
+ * dbname = test_db
+ * [phalcon]
+ * controllersDir = "../app/controllers/"
+ * modelsDir = "../app/models/"
+ * viewsDir = "../app/views/"
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Ini("path/config.ini");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Ini extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Ini constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+ /**
+ * Build multidimensional array from string
+ *
+ * $this->_parseIniString('path.hello.world', 'value for last key');
+ * // result
+ * [
+ * 'path' => [
+ * 'hello' => [
+ * 'world' => 'value for last key',
+ * ],
+ * ],
+ * ];
+ *
+ *
+ * @param string $path
+ * @param mixed $value
+ * @return array
+ */
+ protected function _parseIniString($path, $value) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/config/adapter/Json.php b/ide/2.0.6/Phalcon/config/adapter/Json.php
new file mode 100644
index 000000000..5ee81e9f3
--- /dev/null
+++ b/ide/2.0.6/Phalcon/config/adapter/Json.php
@@ -0,0 +1,29 @@
+
+ * {"phalcon":{"baseuri":"\/phalcon\/"},"models":{"metadata":"memory"}}
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Json("path/config.json");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Json extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Json constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/config/adapter/Php.php b/ide/2.0.6/Phalcon/config/adapter/Php.php
new file mode 100644
index 000000000..1627f9246
--- /dev/null
+++ b/ide/2.0.6/Phalcon/config/adapter/Php.php
@@ -0,0 +1,42 @@
+
+ * array(
+ * 'adapter' => 'Mysql',
+ * 'host' => 'localhost',
+ * 'username' => 'scott',
+ * 'password' => 'cheetah',
+ * 'dbname' => 'test_db'
+ * ),
+ * 'phalcon' => array(
+ * 'controllersDir' => '../app/controllers/',
+ * 'modelsDir' => '../app/models/',
+ * 'viewsDir' => '../app/views/'
+ * ));
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Php("path/config.php");
+ * echo $config->phalcon->controllersDir;
+ * echo $config->database->username;
+ *
+ */
+class Php extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Php constructor
+ *
+ * @param string $filePath
+ */
+ public function __construct($filePath) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/config/adapter/Yaml.php b/ide/2.0.6/Phalcon/config/adapter/Yaml.php
new file mode 100644
index 000000000..d9f5a9fe5
--- /dev/null
+++ b/ide/2.0.6/Phalcon/config/adapter/Yaml.php
@@ -0,0 +1,34 @@
+
+ * phalcon
+ * baseuri: /phalcon/
+ * models:
+ * metadata: memory
+ *
+ * You can read it as follows:
+ *
+ * $config = new Phalcon\Config\Adapter\Yaml("path/config.yaml");
+ * echo $config->phalcon->baseuri;
+ * echo $config->models->metadata;
+ *
+ */
+class Yaml extends \Phalcon\Config
+{
+
+ /**
+ * Phalcon\Config\Adapter\Yaml constructor
+ *
+ * @throws \Phalcon\Config\Exception
+ * @param string $filePath
+ * @param array $callbacks
+ */
+ public function __construct($filePath, $callbacks = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/crypt/Exception.php b/ide/2.0.6/Phalcon/crypt/Exception.php
new file mode 100644
index 000000000..5af7d614f
--- /dev/null
+++ b/ide/2.0.6/Phalcon/crypt/Exception.php
@@ -0,0 +1,12 @@
+
+ * //Getting first robot
+ * $robot = $connection->fecthOne("SELECTFROM robots");
+ * print_r($robot);
+ * //Getting first robot with associative indexes only
+ * $robot = $connection->fecthOne("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param mixed $fetchMode
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return array
+ */
+ public function fetchOne($sqlQuery, $fetchMode = Db::FETCH_ASSOC, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Dumps the complete result of a query into an array
+ *
+ * //Getting all robots with associative indexes only
+ * $robots = $connection->fetchAll("SELECTFROM robots", Phalcon\Db::FETCH_ASSOC);
+ * foreach ($robots as $robot) {
+ * print_r($robot);
+ * }
+ * //Getting all robots that contains word "robot" withing the name
+ * $robots = $connection->fetchAll("SELECTFROM robots WHERE name LIKE :name",
+ * Phalcon\Db::FETCH_ASSOC,
+ * array('name' => '%robot%')
+ * );
+ * foreach($robots as $robot){
+ * print_r($robot);
+ * }
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $fetchMode
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return array
+ */
+ public function fetchAll($sqlQuery, $fetchMode = Db::FETCH_ASSOC, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Returns the n'th field of first row in a SQL query result
+ *
+ * //Getting count of robots
+ * $robotsCount = $connection->fetchColumn("SELECT count(*) FROM robots");
+ * print_r($robotsCount);
+ * //Getting name of last edited robot
+ * $robot = $connection->fetchColumn("SELECT id, name FROM robots order by modified desc", 1);
+ * print_r($robot);
+ *
+ *
+ * @param string $sqlQuery
+ * @param array $placeholders
+ * @param int|string $column
+ * @return string|
+ */
+ public function fetchColumn($sqlQuery, $placeholders = null, $column = 0) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ *
+ * // Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * // Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param string|array $table
+ * @param array $values
+ * @param mixed $fields
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @return
+ */
+ public function insert($table, $values, $fields = null, $dataTypes = null) {}
+
+ /**
+ * Inserts data into a table using custom RBDM SQL syntax
+ *
+ * //Inserting a new robot
+ * $success = $connection->insertAsDict(
+ * "robots",
+ * array(
+ * "name" => "Astro Boy",
+ * "year" => 1952
+ * )
+ * );
+ * //Next SQL sentence is sent to the database system
+ * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $dataTypes
+ * @param $string table
+ * @param $array dataTypes
+ * @return
+ */
+ public function insertAsDict($table, $data, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ * //Updating existing robot with array condition and $dataTypes
+ * $success = $connection->update(
+ * "robots",
+ * array("name"),
+ * array("New Astro Boy"),
+ * array(
+ * 'conditions' => "id = ?",
+ * 'bind' => array($some_unsafe_id),
+ * 'bindTypes' => array(PDO::PARAM_INT) //use only if you use $dataTypes param
+ * ),
+ * array(PDO::PARAM_STR)
+ * );
+ *
+ * Warning! If $whereCondition is string it not escaped.
+ *
+ * @param string|array $table
+ * @param mixed $fields
+ * @param mixed $values
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $array dataTypes
+ * @param $string|array whereCondition
+ * @return
+ */
+ public function update($table, $fields, $values, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Updates data on a table using custom RBDM SQL syntax
+ * Another, more convenient syntax
+ *
+ * //Updating existing robot
+ * $success = $connection->update(
+ * "robots",
+ * array(
+ * "name" => "New Astro Boy"
+ * ),
+ * "id = 101"
+ * );
+ * //Next SQL sentence is sent to the database system
+ * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
+ *
+ *
+ * @param mixed $table
+ * @param mixed $data
+ * @param mixed $whereCondition
+ * @param mixed $dataTypes
+ * @param $string whereCondition
+ * @param $array dataTypes
+ * @return
+ */
+ public function updateAsDict($table, $data, $whereCondition = null, $dataTypes = null) {}
+
+ /**
+ * Deletes data from a table using custom RBDM SQL syntax
+ *
+ * //Deleting existing robot
+ * $success = $connection->delete(
+ * "robots",
+ * "id = 101"
+ * );
+ * //Next SQL sentence is generated
+ * DELETE FROM `robots` WHERE `id` = 101
+ *
+ *
+ * @param string|array $table
+ * @param string $whereCondition
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return boolean
+ */
+ public function delete($table, $whereCondition = null, $placeholders = null, $dataTypes = null) {}
+
+ /**
+ * Gets a list of columns
+ *
+ * @param array columnList
+ * @return string
+ * @param mixed $columnList
+ * @return string
+ */
+ public function getColumnList($columnList) {}
+
+ /**
+ * Appends a LIMIT clause to $sqlQuery argument
+ *
+ * echo $connection->limit("SELECTFROM robots", 5);
+ *
+ *
+ * @param string $sqlQuery
+ * @param int $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.table
+ *
+ * var_dump($connection->tableExists("blog", "posts"));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * var_dump($connection->viewExists("active_users", "posts"));
+ *
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Drops a table from a schema/database
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropTable($tableName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Creates a view
+ *
+ * @param string $viewName
+ * @param array $definition
+ * @param mixed $schemaName
+ * @return bool
+ */
+ public function createView($viewName, $definition, $schemaName = null) {}
+
+ /**
+ * Drops a view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @param bool $ifExists
+ * @return bool
+ */
+ public function dropView($viewName, $schemaName = null, $ifExists = true) {}
+
+ /**
+ * Adds a column to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @return bool
+ */
+ public function addColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Drops a column from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $columnName
+ * @return bool
+ */
+ public function dropColumn($tableName, $schemaName, $columnName) {}
+
+ /**
+ * Adds an index to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addIndex($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drop an index from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $indexName
+ * @return bool
+ */
+ public function dropIndex($tableName, $schemaName, $indexName) {}
+
+ /**
+ * Adds a primary key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $index
+ * @return bool
+ */
+ public function addPrimaryKey($tableName, $schemaName, IndexInterface $index) {}
+
+ /**
+ * Drops a table's primary key
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return bool
+ */
+ public function dropPrimaryKey($tableName, $schemaName) {}
+
+ /**
+ * Adds a foreign key to a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $reference
+ * @return bool
+ */
+ public function addForeignKey($tableName, $schemaName, ReferenceInterface $reference) {}
+
+ /**
+ * Drops a foreign key from a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param string $referenceName
+ * @return bool
+ */
+ public function dropForeignKey($tableName, $schemaName, $referenceName) {}
+
+ /**
+ * Returns the SQL column definition from a column
+ *
+ * @param mixed $column
+ * @return string
+ */
+ public function getColumnDefinition(\Phalcon\Db\ColumnInterface $column) {}
+
+ /**
+ * List all tables on a database
+ *
+ * print_r($connection->listTables("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * List all views on a database
+ *
+ * print_r($connection->listViews("blog"));
+ *
+ *
+ * @param string $schemaName
+ * @return array
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * print_r($connection->describeIndexes('robots_parts'));
+ *
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\Index[]
+ * @param string $table
+ * @param mixed $schema
+ * @return Index
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * print_r($connection->describeReferences('robots_parts'));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return Reference
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Gets creation options from a table
+ *
+ * print_r($connection->tableOptions('robots'));
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return array
+ */
+ public function tableOptions($tableName, $schemaName = null) {}
+
+ /**
+ * Creates a new savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Releases given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Rollbacks given savepoint
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Set if nested transactions should use savepoints
+ *
+ * @param bool $nestedTransactionsWithSavepoints
+ * @return AdapterInterface
+ */
+ public function setNestedTransactionsWithSavepoints($nestedTransactionsWithSavepoints) {}
+
+ /**
+ * Returns if nested transactions should use savepoints
+ *
+ * @return bool
+ */
+ public function isNestedTransactionsWithSavepoints() {}
+
+ /**
+ * Returns the savepoint name to use for nested transactions
+ *
+ * @return string
+ */
+ public function getNestedTransactionSavepointName() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Returns the default value to make the RBDM use the default value declared in the table definition
+ *
+ * //Inserting a new robot with a valid default value for the column 'year'
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", $connection->getDefaultValue()),
+ * array("name", "year")
+ * );
+ *
+ *
+ * @return RawValue
+ */
+ public function getDefaultValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return descriptor used to connect to the active database
+ *
+ * @return array
+ */
+ public function getDescriptor() {}
+
+ /**
+ * Gets the active connection unique identifier
+ *
+ * @return string
+ */
+ public function getConnectionId() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return string
+ */
+ public function getSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object without replace bound paramters
+ *
+ * @return string
+ */
+ public function getRealSQLStatement() {}
+
+ /**
+ * Active SQL statement in the object
+ *
+ * @return array
+ */
+ public function getSQLBindTypes() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/AdapterInterface.php b/ide/2.0.6/Phalcon/db/AdapterInterface.php
new file mode 100644
index 000000000..7726f24de
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/AdapterInterface.php
@@ -0,0 +1,559 @@
+
+ * use Phalcon\Db\Column as Column;
+ * //column definition
+ * $column = new Column("id", array(
+ * "type" => Column::TYPE_INTEGER,
+ * "size" => 10,
+ * "unsigned" => true,
+ * "notNull" => true,
+ * "autoIncrement" => true,
+ * "first" => true
+ * ));
+ * //add column to existing table
+ * $connection->addColumn("robots", null, $column);
+ *
+ */
+class Column implements \Phalcon\Db\ColumnInterface
+{
+ /**
+ * Integer abstract type
+ */
+ const TYPE_INTEGER = 0;
+
+ /**
+ * Date abstract type
+ */
+ const TYPE_DATE = 1;
+
+ /**
+ * Varchar abstract type
+ */
+ const TYPE_VARCHAR = 2;
+
+ /**
+ * Decimal abstract type
+ */
+ const TYPE_DECIMAL = 3;
+
+ /**
+ * Datetime abstract type
+ */
+ const TYPE_DATETIME = 4;
+
+ /**
+ * Char abstract type
+ */
+ const TYPE_CHAR = 5;
+
+ /**
+ * Text abstract data type
+ */
+ const TYPE_TEXT = 6;
+
+ /**
+ * Float abstract data type
+ */
+ const TYPE_FLOAT = 7;
+
+ /**
+ * Boolean abstract data type
+ */
+ const TYPE_BOOLEAN = 8;
+
+ /**
+ * Double abstract data type
+ */
+ const TYPE_DOUBLE = 9;
+
+ /**
+ * Tinyblob abstract data type
+ */
+ const TYPE_TINYBLOB = 10;
+
+ /**
+ * Blob abstract data type
+ */
+ const TYPE_BLOB = 11;
+
+ /**
+ * Mediumblob abstract data type
+ */
+ const TYPE_MEDIUMBLOB = 12;
+
+ /**
+ * Longblob abstract data type
+ */
+ const TYPE_LONGBLOB = 13;
+
+ /**
+ * Big integer abstract type
+ */
+ const TYPE_BIGINTEGER = 14;
+
+ /**
+ * Json abstract type
+ */
+ const TYPE_JSON = 15;
+
+ /**
+ * Jsonb abstract type
+ */
+ const TYPE_JSONB = 16;
+
+ /**
+ * Bind Type Null
+ */
+ const BIND_PARAM_NULL = 0;
+
+ /**
+ * Bind Type Integer
+ */
+ const BIND_PARAM_INT = 1;
+
+ /**
+ * Bind Type String
+ */
+ const BIND_PARAM_STR = 2;
+
+ /**
+ * Bind Type Blob
+ */
+ const BIND_PARAM_BLOB = 3;
+
+ /**
+ * Bind Type Bool
+ */
+ const BIND_PARAM_BOOL = 5;
+
+ /**
+ * Bind Type Decimal
+ */
+ const BIND_PARAM_DECIMAL = 32;
+
+ /**
+ * Skip binding by type
+ */
+ const BIND_SKIP = 1024;
+
+ /**
+ * Column's name
+ *
+ * @var string
+ */
+ protected $_name;
+
+ /**
+ * Schema which table related is
+ *
+ * @var string
+ */
+ protected $_schemaName;
+
+ /**
+ * Column data type
+ *
+ * @var int|string
+ */
+ protected $_type;
+
+ /**
+ * Column data type reference
+ *
+ * @var int
+ */
+ protected $_typeReference;
+
+ /**
+ * Column data type values
+ *
+ * @var array|string
+ */
+ protected $_typeValues;
+
+ /**
+ * The column have some numeric type?
+ */
+ protected $_isNumeric = false;
+
+ /**
+ * Integer column size
+ *
+ * @var int
+ */
+ protected $_size = 0;
+
+ /**
+ * Integer column number scale
+ *
+ * @var int
+ */
+ protected $_scale = 0;
+
+ /**
+ * Default column value
+ */
+ protected $_default = null;
+
+ /**
+ * Integer column unsigned?
+ *
+ * @var boolean
+ */
+ protected $_unsigned = false;
+
+ /**
+ * Column not nullable?
+ *
+ * @var boolean
+ */
+ protected $_notNull = false;
+
+ /**
+ * Column is part of the primary key?
+ */
+ protected $_primary = false;
+
+ /**
+ * Column is autoIncrement?
+ *
+ * @var boolean
+ */
+ protected $_autoIncrement = false;
+
+ /**
+ * Position is first
+ *
+ * @var boolean
+ */
+ protected $_first = false;
+
+ /**
+ * Column Position
+ *
+ * @var string
+ */
+ protected $_after;
+
+ /**
+ * Bind Type
+ */
+ protected $_bindType = 2;
+
+
+ /**
+ * Column's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Schema which table related is
+ *
+ * @return string
+ */
+ public function getSchemaName() {}
+
+ /**
+ * Column data type
+ *
+ * @return int|string
+ */
+ public function getType() {}
+
+ /**
+ * Column data type reference
+ *
+ * @return int
+ */
+ public function getTypeReference() {}
+
+ /**
+ * Column data type values
+ *
+ * @return array|string
+ */
+ public function getTypeValues() {}
+
+ /**
+ * Integer column size
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Integer column number scale
+ *
+ * @return int
+ */
+ public function getScale() {}
+
+ /**
+ * Default column value
+ */
+ public function getDefault() {}
+
+ /**
+ * Phalcon\Db\Column constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Returns true if number column is unsigned
+ *
+ * @return bool
+ */
+ public function isUnsigned() {}
+
+ /**
+ * Not null
+ *
+ * @return bool
+ */
+ public function isNotNull() {}
+
+ /**
+ * Column is part of the primary key?
+ *
+ * @return bool
+ */
+ public function isPrimary() {}
+
+ /**
+ * Auto-Increment
+ *
+ * @return bool
+ */
+ public function isAutoIncrement() {}
+
+ /**
+ * Check whether column have an numeric type
+ *
+ * @return bool
+ */
+ public function isNumeric() {}
+
+ /**
+ * Check whether column have first position in table
+ *
+ * @return bool
+ */
+ public function isFirst() {}
+
+ /**
+ * Check whether field absolute to position in table
+ *
+ * @return string
+ */
+ public function getAfterPosition() {}
+
+ /**
+ * Returns the type of bind handling
+ *
+ * @return int
+ */
+ public function getBindType() {}
+
+ /**
+ * Restores the internal state of a Phalcon\Db\Column object
+ *
+ * @param array $data
+ * @return Column
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/ColumnInterface.php b/ide/2.0.6/Phalcon/db/ColumnInterface.php
new file mode 100644
index 000000000..658903aaf
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/ColumnInterface.php
@@ -0,0 +1,140 @@
+
+ * $sql = $dialect->limit('SELECTFROM robots', 10);
+ * echo $sql; // SELECTFROM robots LIMIT 10
+ * $sql = $dialect->limit('SELECTFROM robots', [10, 50]);
+ * echo $sql; // SELECTFROM robots LIMIT 10 OFFSET 50
+ *
+ *
+ * @param string $sqlQuery
+ * @param mixed $number
+ * @return string
+ */
+ public function limit($sqlQuery, $number) {}
+
+ /**
+ * Returns a SQL modified with a FOR UPDATE clause
+ *
+ * $sql = $dialect->forUpdate('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots FOR UPDATE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function forUpdate($sqlQuery) {}
+
+ /**
+ * Returns a SQL modified with a LOCK IN SHARE MODE clause
+ *
+ * $sql = $dialect->sharedLock('SELECTFROM robots');
+ * echo $sql; // SELECTFROM robots LOCK IN SHARE MODE
+ *
+ *
+ * @param string $sqlQuery
+ * @return string
+ */
+ public function sharedLock($sqlQuery) {}
+
+ /**
+ * Gets a list of columns with escaped identifiers
+ *
+ * echo $dialect->getColumnList(array('column1', 'column'));
+ *
+ *
+ * @param array $columnList
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ public final function getColumnList($columnList, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param mixed $column
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ public final function getSqlColumn($column, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Transforms an intermediate representation for a expression into a database system valid expression
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ public function getSqlExpression($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Transform an intermediate representation of a schema/table into a database system valid expression
+ *
+ * @param mixed $table
+ * @param string $escapeChar
+ * @return string
+ */
+ public final function getSqlTable($table, $escapeChar = null) {}
+
+ /**
+ * Builds a SELECT statement
+ *
+ * @param array $definition
+ * @return string
+ */
+ public function select($definition) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+ /**
+ * Generate SQL to create a new savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function createSavepoint($name) {}
+
+ /**
+ * Generate SQL to release a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function releaseSavepoint($name) {}
+
+ /**
+ * Generate SQL to rollback a savepoint
+ *
+ * @param string $name
+ * @return string
+ */
+ public function rollbackSavepoint($name) {}
+
+ /**
+ * Resolve Column expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionScalar($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve object expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionObject($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve qualified expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionQualified($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve binary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionBinaryOperations($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve unary operations expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionUnaryOperations($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve function calls
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionFunctionCall($expression, $escapeChar = null, $bindCounts) {}
+
+ /**
+ * Resolve Lists
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionList($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionAll($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve CAST of values
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionCastValue($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve CONVERT of values encodings
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionConvertValue($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve CASE expressions
+ *
+ * @param array $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionCase($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a FROM clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @return string
+ */
+ protected final function getSqlExpressionFrom($expression, $escapeChar = null) {}
+
+ /**
+ * Resolve a JOINs clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionJoins($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a WHERE clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionWhere($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a GROUP BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionGroupBy($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a HAVING clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionHaving($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a ORDER BY clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionOrderBy($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Resolve a LIMIT clause
+ *
+ * @param mixed $expression
+ * @param string $escapeChar
+ * @param mixed $bindCounts
+ * @return string
+ */
+ protected final function getSqlExpressionLimit($expression, $escapeChar = null, $bindCounts = null) {}
+
+ /**
+ * Prepares column for this RDBMS
+ *
+ * @param string $qualified
+ * @param string $alias
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareColumnAlias($qualified, $alias = null, $escapeChar = null) {}
+
+ /**
+ * Prepares table for this RDBMS
+ *
+ * @param string $table
+ * @param string $schema
+ * @param string $alias
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareTable($table, $schema = null, $alias = null, $escapeChar = null) {}
+
+ /**
+ * Prepares qualified for this RDBMS
+ *
+ * @param string $column
+ * @param string $domain
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareQualified($column, $domain = null, $escapeChar = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/DialectInterface.php b/ide/2.0.6/Phalcon/db/DialectInterface.php
new file mode 100644
index 000000000..a1deb6019
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/DialectInterface.php
@@ -0,0 +1,290 @@
+
+ * $profiler = new \Phalcon\Db\Profiler();
+ * //Set the connection profiler
+ * $connection->setProfiler($profiler);
+ * $sql = "SELECT buyer_name, quantity, product_name
+ * FROM buyers LEFT JOIN products ON
+ * buyers.pid=products.id";
+ * //Execute a SQL statement
+ * $connection->query($sql);
+ * //Get the last profile in the profiler
+ * $profile = $profiler->getLastProfile();
+ * echo "SQL Statement: ", $profile->getSQLStatement(), "\n";
+ * echo "Start Time: ", $profile->getInitialTime(), "\n";
+ * echo "Final Time: ", $profile->getFinalTime(), "\n";
+ * echo "Total Elapsed Time: ", $profile->getTotalElapsedSeconds(), "\n";
+ *
+ */
+class Profiler
+{
+ /**
+ * All the Phalcon\Db\Profiler\Item in the active profile
+ *
+ * @var \Phalcon\Db\Profiler\Item[]
+ */
+ protected $_allProfiles;
+
+ /**
+ * Active Phalcon\Db\Profiler\Item
+ *
+ * @var Phalcon\Db\Profiler\Item
+ */
+ protected $_activeProfile;
+
+ /**
+ * Total time spent by all profiles to complete
+ *
+ * @var float
+ */
+ protected $_totalSeconds = 0;
+
+
+ /**
+ * Starts the profile of a SQL sentence
+ *
+ * @param string $sqlStatement
+ * @param mixed $sqlVariables
+ * @param mixed $sqlBindTypes
+ * @return \Phalcon\Db\Profiler
+ */
+ public function startProfile($sqlStatement, $sqlVariables = null, $sqlBindTypes = null) {}
+
+ /**
+ * Stops the active profile
+ *
+ * @return Profiler
+ */
+ public function stopProfile() {}
+
+ /**
+ * Returns the total number of SQL statements processed
+ *
+ * @return int
+ */
+ public function getNumberTotalStatements() {}
+
+ /**
+ * Returns the total time in seconds spent by the profiles
+ *
+ * @return double
+ */
+ public function getTotalElapsedSeconds() {}
+
+ /**
+ * Returns all the processed profiles
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getProfiles() {}
+
+ /**
+ * Resets the profiler, cleaning up all the profiles
+ *
+ * @return Profiler
+ */
+ public function reset() {}
+
+ /**
+ * Returns the last profile executed in the profiler
+ *
+ * @return \Phalcon\Db\Profiler\Item
+ */
+ public function getLastProfile() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/RawValue.php b/ide/2.0.6/Phalcon/db/RawValue.php
new file mode 100644
index 000000000..fe66e8fd4
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/RawValue.php
@@ -0,0 +1,45 @@
+
+ * $subscriber = new Subscribers();
+ * $subscriber->email = 'andres@phalconphp.com';
+ * $subscriber->createdAt = new \Phalcon\Db\RawValue('now()');
+ * $subscriber->save();
+ *
+ */
+class RawValue
+{
+ /**
+ * Raw value without quoting or formating
+ *
+ * @var string
+ */
+ protected $_value;
+
+
+ /**
+ * Raw value without quoting or formating
+ *
+ * @return string
+ */
+ public function getValue() {}
+
+ /**
+ * Raw value without quoting or formating
+ */
+ public function __toString() {}
+
+ /**
+ * Phalcon\Db\RawValue constructor
+ *
+ * @param mixed $value
+ */
+ public function __construct($value) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/Reference.php b/ide/2.0.6/Phalcon/db/Reference.php
new file mode 100644
index 000000000..ad0ca1f80
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/Reference.php
@@ -0,0 +1,132 @@
+
+ * $reference = new \Phalcon\Db\Reference("field_fk", array(
+ * 'referencedSchema' => "invoicing",
+ * 'referencedTable' => "products",
+ * 'columns' => array("product_type", "product_code"),
+ * 'referencedColumns' => array("type", "code")
+ * ));
+ *
+ */
+class Reference implements \Phalcon\Db\ReferenceInterface
+{
+ /**
+ * Constraint name
+ *
+ * @var string
+ */
+ protected $_name;
+
+
+ protected $_schemaName;
+
+
+ protected $_referencedSchema;
+
+ /**
+ * Referenced Table
+ *
+ * @var string
+ */
+ protected $_referencedTable;
+
+ /**
+ * Local reference columns
+ *
+ * @var array
+ */
+ protected $_columns;
+
+ /**
+ * Referenced Columns
+ *
+ * @var array
+ */
+ protected $_referencedColumns;
+
+ /**
+ * ON DELETE
+ *
+ * @var array
+ */
+ protected $_onDelete;
+
+ /**
+ * ON UPDATE
+ *
+ * @var array
+ */
+ protected $_onUpdate;
+
+
+ /**
+ * Constraint name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+
+ public function getSchemaName() {}
+
+
+ public function getReferencedSchema() {}
+
+ /**
+ * Referenced Table
+ *
+ * @return string
+ */
+ public function getReferencedTable() {}
+
+ /**
+ * Local reference columns
+ *
+ * @return array
+ */
+ public function getColumns() {}
+
+ /**
+ * Referenced Columns
+ *
+ * @return array
+ */
+ public function getReferencedColumns() {}
+
+ /**
+ * ON DELETE
+ *
+ * @return array
+ */
+ public function getOnDelete() {}
+
+ /**
+ * ON UPDATE
+ *
+ * @return array
+ */
+ public function getOnUpdate() {}
+
+ /**
+ * Phalcon\Db\Reference constructor
+ *
+ * @param string $name
+ * @param array $definition
+ */
+ public function __construct($name, $definition) {}
+
+ /**
+ * Restore a Phalcon\Db\Reference object from export
+ *
+ * @param array $data
+ * @return Reference
+ */
+ public static function __set_state($data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/ReferenceInterface.php b/ide/2.0.6/Phalcon/db/ReferenceInterface.php
new file mode 100644
index 000000000..89e52781f
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/ReferenceInterface.php
@@ -0,0 +1,84 @@
+
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * 'port' => '3306'
+ * ));
+ *
+ */
+abstract class Pdo extends \Phalcon\Db\Adapter
+{
+ /**
+ * PDO Handler
+ */
+ protected $_pdo;
+
+ /**
+ * Last affected rows
+ */
+ protected $_affectedRows;
+
+
+ /**
+ * Constructor for Phalcon\Db\Adapter\Pdo
+ *
+ * @param array $descriptor
+ */
+ public function __construct($descriptor) {}
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection
+ *
+ * //Make a connection
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql(array(
+ * 'host' => '192.168.0.11',
+ * 'username' => 'sigma',
+ * 'password' => 'secret',
+ * 'dbname' => 'blog',
+ * ));
+ * //Reconnect
+ * $connection->connect();
+ *
+ *
+ * @param mixed $descriptor
+ * @param $array descriptor
+ * @return
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns a PDO prepared statement to be executed with 'executePrepared'
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param string $sqlStatement
+ * @return \PDOStatement
+ */
+ public function prepare($sqlStatement) {}
+
+ /**
+ * Executes a prepared statement binding. This function uses integer indexes starting from zero
+ *
+ * $statement = $db->prepare('SELECTFROM robots WHERE name = :name');
+ * $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
+ *
+ *
+ * @param \PDOStatement $statement
+ * @param array $placeholders
+ * @param array $dataTypes
+ * @return \PDOStatement
+ */
+ public function executePrepared(\PDOStatement $statement, $placeholders, $dataTypes) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server is returning rows
+ *
+ * //Querying data
+ * $resultset = $connection->query("SELECTFROM robots WHERE type='mechanical'");
+ * $resultset = $connection->query("SELECTFROM robots WHERE type=?", array("mechanical"));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool|\Phalcon\Db\ResultInterface
+ */
+ public function query($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sends SQL statements to the database server returning the success state.
+ * Use this method only when the SQL statement sent to the server doesn't return any rows
+ *
+ * //Inserting data
+ * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
+ * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
+ *
+ *
+ * @param string $sqlStatement
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return bool
+ */
+ public function execute($sqlStatement, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Returns the number of affected rows by the lastest INSERT/UPDATE/DELETE executed in the database system
+ *
+ * $connection->execute("DELETE FROM robots");
+ * echo $connection->affectedRows(), ' were deleted';
+ *
+ *
+ * @return int
+ */
+ public function affectedRows() {}
+
+ /**
+ * Closes the active connection returning success. Phalcon automatically closes and destroys
+ * active connections when the request ends
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * $escapedTable = $connection->escapeIdentifier('robots');
+ * $escapedTable = $connection->escapeIdentifier(array('store', 'robots'));
+ *
+ *
+ * @param string $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Escapes a value to avoid SQL injections according to the active charset in the connection
+ *
+ * $escapedStr = $connection->escapeString('some dangerous value');
+ *
+ *
+ * @param string $str
+ * @return string
+ */
+ public function escapeString($str) {}
+
+ /**
+ * Converts bound parameters such as :name: or ?1 into PDO bind params ?
+ *
+ * print_r($connection->convertBoundParams('SELECTFROM robots WHERE name = :name:', array('Bender')));
+ *
+ *
+ * @param string $sql
+ * @param array $params
+ * @return array
+ */
+ public function convertBoundParams($sql, $params = array()) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int|boolean
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Starts a transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function begin($nesting = true) {}
+
+ /**
+ * Rollbacks the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function rollback($nesting = true) {}
+
+ /**
+ * Commits the active transaction in the connection
+ *
+ * @param bool $nesting
+ * @return bool
+ */
+ public function commit($nesting = true) {}
+
+ /**
+ * Returns the current transaction nesting level
+ *
+ * @return int
+ */
+ public function getTransactionLevel() {}
+
+ /**
+ * Checks whether the connection is under a transaction
+ *
+ * $connection->begin();
+ * var_dump($connection->isUnderTransaction()); //true
+ *
+ *
+ * @return bool
+ */
+ public function isUnderTransaction() {}
+
+ /**
+ * Return internal PDO handler
+ *
+ * @return \Pdo
+ */
+ public function getInternalHandler() {}
+
+ /**
+ * Return the error info, if any
+ *
+ * @return array
+ */
+ public function getErrorInfo() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/adapter/pdo/Mysql.php b/ide/2.0.6/Phalcon/db/adapter/pdo/Mysql.php
new file mode 100644
index 000000000..dec124c0e
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/adapter/pdo/Mysql.php
@@ -0,0 +1,48 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "port" => 3306,
+ * "username" => "sigma",
+ * "password" => "secret"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Mysql($config);
+ *
+ */
+class Mysql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "mysql";
+
+
+ protected $_dialectType = "mysql";
+
+
+ /**
+ * Escapes a column/table/schema name
+ *
+ * @param string|array $identifier
+ * @return string
+ */
+ public function escapeIdentifier($identifier) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/adapter/pdo/Oracle.php b/ide/2.0.6/Phalcon/db/adapter/pdo/Oracle.php
new file mode 100644
index 000000000..9e45aea25
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/adapter/pdo/Oracle.php
@@ -0,0 +1,84 @@
+
+ * $config = array(
+ * "dbname" => "//localhost/dbname",
+ * "username" => "oracle",
+ * "password" => "oracle"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Oracle($config);
+ *
+ */
+class Oracle extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "oci";
+
+
+ protected $_dialectType = "oracle";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param array $descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ * print_r($connection->describeColumns("posts")); ?>
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Returns the insert id for the auto_increment/serial column inserted in the lastest executed SQL statement
+ *
+ * //Inserting a new robot
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", 1952),
+ * array("name", "year")
+ * );
+ * //Getting the generated id
+ * $id = $connection->lastInsertId();
+ *
+ *
+ * @param string $sequenceName
+ * @return int
+ */
+ public function lastInsertId($sequenceName = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Return the default identity value to insert in an identity column
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/adapter/pdo/Postgresql.php b/ide/2.0.6/Phalcon/db/adapter/pdo/Postgresql.php
new file mode 100644
index 000000000..301ae233c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/adapter/pdo/Postgresql.php
@@ -0,0 +1,99 @@
+
+ * $config = array(
+ * "host" => "192.168.0.11",
+ * "dbname" => "blog",
+ * "username" => "postgres",
+ * "password" => ""
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Postgresql($config);
+ *
+ */
+class Postgresql extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "pgsql";
+
+
+ protected $_dialectType = "postgresql";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Creates a table
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param array $definition
+ * @return bool
+ */
+ public function createTable($tableName, $schemaName, $definition) {}
+
+ /**
+ * Modifies a table column based on a definition
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @param mixed $column
+ * @param mixed $currentColumn
+ * @return bool
+ */
+ public function modifyColumn($tableName, $schemaName, \Phalcon\Db\ColumnInterface $column, \Phalcon\Db\ColumnInterface $currentColumn = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Returns the default identity value to be inserted in an identity column
+ *
+ * //Inserting a new robot with a valid default value for the column 'id'
+ * $success = $connection->insert(
+ * "robots",
+ * array($connection->getDefaultIdValue(), "Astro Boy", 1952),
+ * array("id", "name", "year")
+ * );
+ *
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultIdValue() {}
+
+ /**
+ * Check whether the database system requires a sequence to produce auto-numeric values
+ *
+ * @return bool
+ */
+ public function supportSequences() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/adapter/pdo/Sqlite.php b/ide/2.0.6/Phalcon/db/adapter/pdo/Sqlite.php
new file mode 100644
index 000000000..2a89f63eb
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/adapter/pdo/Sqlite.php
@@ -0,0 +1,92 @@
+
+ * $config = array(
+ * "dbname" => "/tmp/test.sqlite"
+ * );
+ * $connection = new \Phalcon\Db\Adapter\Pdo\Sqlite($config);
+ *
+ */
+class Sqlite extends \Phalcon\Db\Adapter\Pdo implements \Phalcon\Db\AdapterInterface
+{
+
+ protected $_type = "sqlite";
+
+
+ protected $_dialectType = "sqlite";
+
+
+ /**
+ * This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
+ * Call it when you need to restore a database connection.
+ *
+ * @param mixed $descriptor
+ * @param array $$descriptor
+ * @return boolean
+ */
+ public function connect($descriptor = null) {}
+
+ /**
+ * Returns an array of Phalcon\Db\Column objects describing a table
+ *
+ * print_r($connection->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return \Phalcon\Db\Column
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * Lists table indexes
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\IndexInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\IndexInterface
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Lists table references
+ *
+ * @param string table
+ * @param string schema
+ * @return Phalcon\Db\ReferenceInterface[]
+ * @param mixed $table
+ * @param mixed $schema
+ * @return \Phalcon\Db\ReferenceInterface
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Check whether the database system requires an explicit value for identity columns
+ *
+ * @return bool
+ */
+ public function useExplicitIdValue() {}
+
+ /**
+ * Returns the default value to make the RBDM use the default value declared in the table definition
+ *
+ * //Inserting a new robot with a valid default value for the column 'year'
+ * $success = $connection->insert(
+ * "robots",
+ * array("Astro Boy", $connection->getDefaultValue()),
+ * array("name", "year")
+ * );
+ *
+ *
+ * @return \Phalcon\Db\RawValue
+ */
+ public function getDefaultValue() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/dialect/MySQL.php b/ide/2.0.6/Phalcon/db/dialect/MySQL.php
new file mode 100644
index 000000000..6e8af8d16
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/dialect/MySQL.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Generates SQL to add the table creation options
+ *
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/dialect/Oracle.php b/ide/2.0.6/Phalcon/db/dialect/Oracle.php
new file mode 100644
index 000000000..b309e1941
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/dialect/Oracle.php
@@ -0,0 +1,268 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * Checks whether the platform supports savepoints
+ *
+ * @return bool
+ */
+ public function supportsSavepoints() {}
+
+ /**
+ * Checks whether the platform supports releasing savepoints.
+ *
+ * @return bool
+ */
+ public function supportsReleaseSavepoints() {}
+
+ /**
+ * Prepares table for this RDBMS
+ *
+ * @param string $table
+ * @param string $schema
+ * @param string $alias
+ * @param string $escapeChar
+ * @return string
+ */
+ protected function prepareTable($table, $schema = null, $alias = null, $escapeChar = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/dialect/Postgresql.php b/ide/2.0.6/Phalcon/db/dialect/Postgresql.php
new file mode 100644
index 000000000..0a3b9f37e
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/dialect/Postgresql.php
@@ -0,0 +1,239 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+ /**
+ * @param array $definition
+ * @return string
+ */
+ protected function _getTableOptions($definition) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/dialect/Sqlite.php b/ide/2.0.6/Phalcon/db/dialect/Sqlite.php
new file mode 100644
index 000000000..c606ad0c5
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/dialect/Sqlite.php
@@ -0,0 +1,241 @@
+
+ * echo $dialect->tableExists("posts", "blog");
+ * echo $dialect->tableExists("posts");
+ *
+ *
+ * @param string $tableName
+ * @param string $schemaName
+ * @return string
+ */
+ public function tableExists($tableName, $schemaName = null) {}
+
+ /**
+ * Generates SQL checking for the existence of a schema.view
+ *
+ * @param string $viewName
+ * @param string $schemaName
+ * @return string
+ */
+ public function viewExists($viewName, $schemaName = null) {}
+
+ /**
+ * Generates SQL describing a table
+ *
+ * print_r($dialect->describeColumns("posts"));
+ *
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeColumns($table, $schema = null) {}
+
+ /**
+ * List all tables in database
+ *
+ * print_r($dialect->listTables("blog"))
+ *
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listTables($schemaName = null) {}
+
+ /**
+ * Generates the SQL to list all views of a schema or user
+ *
+ * @param string $schemaName
+ * @return string
+ */
+ public function listViews($schemaName = null) {}
+
+ /**
+ * Generates SQL to query indexes on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeIndexes($table, $schema = null) {}
+
+ /**
+ * Generates SQL to query indexes detail on a table
+ *
+ * @param string $index
+ * @return string
+ */
+ public function describeIndex($index) {}
+
+ /**
+ * Generates SQL to query foreign keys on a table
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function describeReferences($table, $schema = null) {}
+
+ /**
+ * Generates the SQL to describe the table creation options
+ *
+ * @param string $table
+ * @param string $schema
+ * @return string
+ */
+ public function tableOptions($table, $schema = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/db/profiler/Item.php b/ide/2.0.6/Phalcon/db/profiler/Item.php
new file mode 100644
index 000000000..79ad83855
--- /dev/null
+++ b/ide/2.0.6/Phalcon/db/profiler/Item.php
@@ -0,0 +1,124 @@
+
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = $result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ */
+class Pdo implements \Phalcon\Db\ResultInterface
+{
+
+ protected $_connection;
+
+
+ protected $_result;
+
+ /**
+ * Active fetch mode
+ */
+ protected $_fetchMode = Db::FETCH_OBJ;
+
+ /**
+ * Internal resultset
+ *
+ * @var \PDOStatement
+ */
+ protected $_pdoStatement;
+
+
+ protected $_sqlStatement;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_rowCount = false;
+
+
+ /**
+ * Phalcon\Db\Result\Pdo constructor
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \PDOStatement $result
+ * @param string $sqlStatement
+ * @param array $bindParams
+ * @param array $bindTypes
+ */
+ public function __construct(Db\AdapterInterface $connection, \PDOStatement $result, $sqlStatement = null, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Allows to execute the statement again. Some database systems don't support scrollable cursors,
+ * So, as cursors are forward only, we need to execute the cursor again to fetch rows from the begining
+ *
+ * @return bool
+ */
+ public function execute() {}
+
+ /**
+ * Fetches an array/object of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ * while ($robot = $result->fetch()) {
+ * echo $robot->name;
+ * }
+ *
+ *
+ * @param mixed $fetchStyle
+ * @param mixed $cursorOrientation
+ * @param mixed $cursorOffset
+ */
+ public function fetch($fetchStyle = null, $cursorOrientation = null, $cursorOffset = null) {}
+
+ /**
+ * Returns an array of strings that corresponds to the fetched row, or FALSE if there are no more rows.
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * while ($robot = result->fetchArray()) {
+ * print_r($robot);
+ * }
+ *
+ */
+ public function fetchArray() {}
+
+ /**
+ * Returns an array of arrays containing all the records in the result
+ * This method is affected by the active fetch flag set using Phalcon\Db\Result\Pdo::setFetchMode
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $robots = $result->fetchAll();
+ *
+ *
+ * @param mixed $fetchStyle
+ * @param mixed $fetchArgument
+ * @param mixed $ctorArgs
+ * @return array
+ */
+ public function fetchAll($fetchStyle = null, $fetchArgument = null, $ctorArgs = null) {}
+
+ /**
+ * Gets number of rows returned by a resultset
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * echo 'There are ', $result->numRows(), ' rows in the resultset';
+ *
+ *
+ * @return int
+ */
+ public function numRows() {}
+
+ /**
+ * Moves internal resultset cursor to another position letting us to fetch a certain row
+ *
+ * $result = $connection->query("SELECTFROM robots ORDER BY name");
+ * $result->dataSeek(2); // Move to third row on result
+ * $row = $result->fetch(); // Fetch third row
+ *
+ *
+ * @param long $number
+ */
+ public function dataSeek($number) {}
+
+ /**
+ * Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch()
+ *
+ * //Return array with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_NUM);
+ * //Return associative array without integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_ASSOC);
+ * //Return associative array together with integer indexes
+ * $result->setFetchMode(Phalcon\Db::FETCH_BOTH);
+ * //Return an object
+ * $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
+ *
+ *
+ * @param int $fetchMode
+ * @param mixed $colNoOrClassNameOrObject
+ * @param mixed $ctorargs
+ * @return bool
+ */
+ public function setFetchMode($fetchMode, $colNoOrClassNameOrObject = null, $ctorargs = null) {}
+
+ /**
+ * Gets the internal PDO result object
+ *
+ * @return \PDOStatement
+ */
+ public function getInternalResult() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/debug/Dump.php b/ide/2.0.6/Phalcon/debug/Dump.php
new file mode 100644
index 000000000..6d610b011
--- /dev/null
+++ b/ide/2.0.6/Phalcon/debug/Dump.php
@@ -0,0 +1,134 @@
+
+ * $foo = 123;
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ */
+class Dump
+{
+
+ protected $_detailed = false;
+
+
+ protected $_methods = null;
+
+
+ protected $_styles;
+
+
+
+ public function getDetailed() {}
+
+ /**
+ * @param mixed $detailed
+ */
+ public function setDetailed($detailed) {}
+
+ /**
+ * Phalcon\Debug\Dump constructor
+ *
+ * @param array $styles
+ * @param boolean $detailed debug object's private and protected properties
+ */
+ public function __construct($styles = null, $detailed = false) {}
+
+ /**
+ * Alias of variables() method
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function all() {}
+
+ /**
+ * Get style for type
+ *
+ * @param string $type
+ * @return string
+ */
+ protected function getStyle($type) {}
+
+ /**
+ * Set styles for vars type
+ *
+ * @param mixed $styles
+ * @return array
+ */
+ public function setStyles($styles = null) {}
+
+ /**
+ * Alias of variable() method
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function one($variable, $name = null) {}
+
+ /**
+ * Prepare an HTML string of information about a single variable.
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @param int $tab
+ * @return string
+ */
+ protected function output($variable, $name = null, $tab = 1) {}
+
+ /**
+ * Returns an HTML string of information about a single variable.
+ *
+ * echo (new \Phalcon\Debug\Dump())->variable($foo, "foo");
+ *
+ *
+ * @param mixed $variable
+ * @param string $name
+ * @return string
+ */
+ public function variable($variable, $name = null) {}
+
+ /**
+ * Returns an HTML string of debugging information about any number of
+ * variables, each wrapped in a "pre" tag.
+ *
+ * $foo = "string";
+ * $bar = ["key" => "value"];
+ * $baz = new stdClass();
+ * echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
+ *
+ *
+ * @param mixed $variable
+ * @param ...
+ * @return string
+ */
+ public function variables() {}
+
+ /**
+ * Returns an JSON string of information about a single variable.
+ *
+ * $foo = ["key" => "value"];
+ * echo (new \Phalcon\Debug\Dump())->toJson($foo);
+ * $foo = new stdClass();
+ * $foo->bar = 'buz';
+ * echo (new \Phalcon\Debug\Dump())->toJson($foo);
+ *
+ *
+ * @param mixed $variable
+ * @return string
+ */
+ public function toJson($variable) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/debug/Exception.php b/ide/2.0.6/Phalcon/debug/Exception.php
new file mode 100644
index 000000000..12c2c2b76
--- /dev/null
+++ b/ide/2.0.6/Phalcon/debug/Exception.php
@@ -0,0 +1,12 @@
+
+ * $service = new \Phalcon\Di\Service('request', 'Phalcon\Http\Request');
+ * $request = service->resolve();
+ *
+ */
+class Service implements \Phalcon\Di\ServiceInterface
+{
+
+ protected $_name;
+
+
+ protected $_definition;
+
+
+ protected $_shared = false;
+
+
+ protected $_resolved = false;
+
+
+ protected $_sharedInstance;
+
+
+ /**
+ * Phalcon\Di\Service
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @param boolean $shared
+ */
+ public final function __construct($name, $definition, $shared = false) {}
+
+ /**
+ * Returns the service's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets if the service is shared or not
+ *
+ * @param bool $shared
+ */
+ public function setShared($shared) {}
+
+ /**
+ * Check whether the service is shared or not
+ *
+ * @return bool
+ */
+ public function isShared() {}
+
+ /**
+ * Sets/Resets the shared instance related to the service
+ *
+ * @param mixed $sharedInstance
+ */
+ public function setSharedInstance($sharedInstance) {}
+
+ /**
+ * Set the service definition
+ *
+ * @param mixed $definition
+ */
+ public function setDefinition($definition) {}
+
+ /**
+ * Returns the service definition
+ *
+ * @return mixed
+ */
+ public function getDefinition() {}
+
+ /**
+ * Resolves the service
+ *
+ * @param array $parameters
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @return mixed
+ */
+ public function resolve($parameters = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Changes a parameter in the definition without resolve the service
+ *
+ * @param int $position
+ * @param array $parameter
+ * @return Service
+ */
+ public function setParameter($position, $parameter) {}
+
+ /**
+ * Returns a parameter in a specific position
+ *
+ * @param int $position
+ * @return array
+ */
+ public function getParameter($position) {}
+
+ /**
+ * Returns true if the service was resolved
+ *
+ * @return bool
+ */
+ public function isResolved() {}
+
+ /**
+ * Restore the internal state of a service
+ *
+ * @param array $attributes
+ * @return Service
+ */
+ public static function __set_state($attributes) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/di/ServiceInterface.php b/ide/2.0.6/Phalcon/di/ServiceInterface.php
new file mode 100644
index 000000000..97df909cf
--- /dev/null
+++ b/ide/2.0.6/Phalcon/di/ServiceInterface.php
@@ -0,0 +1,73 @@
+
+ * $eventsManager->fire('db', $connection);
+ *
+ *
+ * @param string $eventType
+ * @param object $source
+ * @param mixed $data
+ * @param boolean $cancelable
+ * @return mixed
+ */
+ public function fire($eventType, $source, $data = null, $cancelable = true) {}
+
+ /**
+ * Check whether certain type of event has listeners
+ *
+ * @param string $type
+ * @return bool
+ */
+ public function hasListeners($type) {}
+
+ /**
+ * Returns all the attached listeners of a certain type
+ *
+ * @param string $type
+ * @return array
+ */
+ public function getListeners($type) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/events/ManagerInterface.php b/ide/2.0.6/Phalcon/events/ManagerInterface.php
new file mode 100644
index 000000000..7a60e4162
--- /dev/null
+++ b/ide/2.0.6/Phalcon/events/ManagerInterface.php
@@ -0,0 +1,55 @@
+
+ * $request = new \Phalcon\Http\Request();
+ * if ($request->isPost() == true) {
+ * if ($request->isAjax() == true) {
+ * echo 'Request was made using POST and AJAX';
+ * }
+ * }
+ *
+ */
+class Request implements \Phalcon\Http\RequestInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_rawBody;
+
+
+ protected $_filter;
+
+
+ protected $_putCache;
+
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Gets a variable from the $_REQUEST superglobal applying filters if needed.
+ * If no parameters are given the $_REQUEST superglobal is returned
+ *
+ * //Returns value from $_REQUEST["user_email"] without sanitizing
+ * $userEmail = $request->get("user_email");
+ * //Returns value from $_REQUEST["user_email"] with sanitizing
+ * $userEmail = $request->get("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function get($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from the $_POST superglobal applying filters if needed
+ * If no parameters are given the $_POST superglobal is returned
+ *
+ * //Returns value from $_POST["user_email"] without sanitizing
+ * $userEmail = $request->getPost("user_email");
+ * //Returns value from $_POST["user_email"] with sanitizing
+ * $userEmail = $request->getPost("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPost($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets a variable from put request
+ *
+ * //Returns value from $_PUT["user_email"] without sanitizing
+ * $userEmail = $request->getPut("user_email");
+ * //Returns value from $_PUT["user_email"] with sanitizing
+ * $userEmail = $request->getPut("user_email", "email");
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getPut($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_GET superglobal applying filters if needed
+ * If no parameters are given the $_GET superglobal is returned
+ *
+ * //Returns value from $_GET["id"] without sanitizing
+ * $id = $request->getQuery("id");
+ * //Returns value from $_GET["id"] with sanitizing
+ * $id = $request->getQuery("id", "int");
+ * //Returns value from $_GET["id"] with a default value
+ * $id = $request->getQuery("id", null, 150);
+ *
+ *
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ public function getQuery($name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Helper to get data from superglobals, applying filters if needed.
+ * If no parameters are given the superglobal is returned.
+ *
+ * @param array $source
+ * @param string $name
+ * @param mixed $filters
+ * @param mixed $defaultValue
+ * @param bool $notAllowEmpty
+ * @param bool $noRecursive
+ */
+ protected final function getHelper($source, $name = null, $filters = null, $defaultValue = null, $notAllowEmpty = false, $noRecursive = false) {}
+
+ /**
+ * Gets variable from $_SERVER superglobal
+ *
+ * @param string $name
+ */
+ public function getServer($name) {}
+
+ /**
+ * Checks whether $_REQUEST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function has($name) {}
+
+ /**
+ * Checks whether $_POST superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPost($name) {}
+
+ /**
+ * Checks whether the PUT data has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasPut($name) {}
+
+ /**
+ * Checks whether $_GET superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function hasQuery($name) {}
+
+ /**
+ * Checks whether $_SERVER superglobal has certain index
+ *
+ * @param string $name
+ * @return bool
+ */
+ public final function hasServer($name) {}
+
+ /**
+ * Gets HTTP header from request data
+ *
+ * @param string $header
+ * @return string
+ */
+ public final function getHeader($header) {}
+
+ /**
+ * Gets HTTP schema (http/https)
+ *
+ * @return string
+ */
+ public function getScheme() {}
+
+ /**
+ * Checks whether request has been made using ajax
+ *
+ * @return bool
+ */
+ public function isAjax() {}
+
+ /**
+ * Checks whether request has been made using SOAP
+ *
+ * @return bool
+ */
+ public function isSoapRequested() {}
+
+ /**
+ * Checks whether request has been made using any secure layer
+ *
+ * @return bool
+ */
+ public function isSecureRequest() {}
+
+ /**
+ * Gets HTTP raw request body
+ *
+ * @return string
+ */
+ public function getRawBody() {}
+
+ /**
+ * Gets decoded JSON HTTP raw request body
+ *
+ * @param bool $associative
+ * @return array|bool|\stdClass
+ */
+ public function getJsonRawBody($associative = false) {}
+
+ /**
+ * Gets active server address IP
+ *
+ * @return string
+ */
+ public function getServerAddress() {}
+
+ /**
+ * Gets active server name
+ *
+ * @return string
+ */
+ public function getServerName() {}
+
+ /**
+ * Gets information about schema, host and port used by the request
+ *
+ * @return string
+ */
+ public function getHttpHost() {}
+
+ /**
+ * Gets HTTP URI which request has been made
+ *
+ * @return string
+ */
+ public final function getURI() {}
+
+ /**
+ * Gets most possible client IPv4 Address. This method search in _SERVER['REMOTE_ADDR'] and optionally in _SERVER['HTTP_X_FORWARDED_FOR']
+ *
+ * @param bool $trustForwardedHeader
+ * @return string|bool
+ */
+ public function getClientAddress($trustForwardedHeader = false) {}
+
+ /**
+ * Gets HTTP method which request has been made
+ *
+ * @return string
+ */
+ public final function getMethod() {}
+
+ /**
+ * Gets HTTP user agent used to made the request
+ *
+ * @return string
+ */
+ public function getUserAgent() {}
+
+ /**
+ * Checks if a method is a valid HTTP method
+ *
+ * @param string $method
+ * @return bool
+ */
+ public function isValidHttpMethod($method) {}
+
+ /**
+ * Check if HTTP method match any of the passed methods
+ * When strict is true it checks if validated methods are real HTTP methods
+ *
+ * @param mixed $methods
+ * @param bool $strict
+ * @return bool
+ */
+ public function isMethod($methods, $strict = false) {}
+
+ /**
+ * Checks whether HTTP method is POST. if _SERVER["REQUEST_METHOD"]==="POST"
+ *
+ * @return bool
+ */
+ public function isPost() {}
+
+ /**
+ * Checks whether HTTP method is GET. if _SERVER["REQUEST_METHOD"]==="GET"
+ *
+ * @return bool
+ */
+ public function isGet() {}
+
+ /**
+ * Checks whether HTTP method is PUT. if _SERVER["REQUEST_METHOD"]==="PUT"
+ *
+ * @return bool
+ */
+ public function isPut() {}
+
+ /**
+ * Checks whether HTTP method is PATCH. if _SERVER["REQUEST_METHOD"]==="PATCH"
+ *
+ * @return bool
+ */
+ public function isPatch() {}
+
+ /**
+ * Checks whether HTTP method is HEAD. if _SERVER["REQUEST_METHOD"]==="HEAD"
+ *
+ * @return bool
+ */
+ public function isHead() {}
+
+ /**
+ * Checks whether HTTP method is DELETE. if _SERVER["REQUEST_METHOD"]==="DELETE"
+ *
+ * @return bool
+ */
+ public function isDelete() {}
+
+ /**
+ * Checks whether HTTP method is OPTIONS. if _SERVER["REQUEST_METHOD"]==="OPTIONS"
+ *
+ * @return bool
+ */
+ public function isOptions() {}
+
+ /**
+ * Checks whether request include attached files
+ *
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ public function hasFiles($onlySuccessful = false) {}
+
+ /**
+ * Recursively counts file in an array of files
+ *
+ * @param mixed $data
+ * @param bool $onlySuccessful
+ * @return long
+ */
+ protected final function hasFileHelper($data, $onlySuccessful) {}
+
+ /**
+ * Gets attached files as Phalcon\Http\Request\File instances
+ *
+ * @param bool $onlySuccessful
+ * @return \Phalcon\Http\Request\File
+ */
+ public function getUploadedFiles($onlySuccessful = false) {}
+
+ /**
+ * Smooth out $_FILES to have plain array with all files uploaded
+ *
+ * @param array $names
+ * @param array $types
+ * @param array $tmp_names
+ * @param array $sizes
+ * @param array $errors
+ * @param string $prefix
+ * @return array
+ */
+ protected final function smoothFiles($names, $types, $tmp_names, $sizes, $errors, $prefix) {}
+
+ /**
+ * Returns the available headers in the request
+ *
+ * @return array
+ */
+ public function getHeaders() {}
+
+ /**
+ * Gets web page that refers active request. ie: http://www.google.com
+ *
+ * @return string
+ */
+ public function getHTTPReferer() {}
+
+ /**
+ * Process a request header and return an array of values with their qualities
+ *
+ * @param string $serverIndex
+ * @param string $name
+ * @return array
+ */
+ protected final function _getQualityHeader($serverIndex, $name) {}
+
+ /**
+ * Process a request header and return the one with best quality
+ *
+ * @param array $qualityParts
+ * @param string $name
+ * @return string
+ */
+ protected final function _getBestQuality($qualityParts, $name) {}
+
+ /**
+ * Gets content type which request has been made
+ *
+ * @return string|null
+ */
+ public function getContentType() {}
+
+ /**
+ * Gets an array with mime/types and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return array
+ */
+ public function getAcceptableContent() {}
+
+ /**
+ * Gets best mime/type accepted by the browser/client from _SERVER["HTTP_ACCEPT"]
+ *
+ * @return string
+ */
+ public function getBestAccept() {}
+
+ /**
+ * Gets a charsets array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return variable
+ */
+ public function getClientCharsets() {}
+
+ /**
+ * Gets best charset accepted by the browser/client from _SERVER["HTTP_ACCEPT_CHARSET"]
+ *
+ * @return string
+ */
+ public function getBestCharset() {}
+
+ /**
+ * Gets languages array and their quality accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return array
+ */
+ public function getLanguages() {}
+
+ /**
+ * Gets best language accepted by the browser/client from _SERVER["HTTP_ACCEPT_LANGUAGE"]
+ *
+ * @return string
+ */
+ public function getBestLanguage() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_USER']
+ *
+ * @return array|null
+ */
+ public function getBasicAuth() {}
+
+ /**
+ * Gets auth info accepted by the browser/client from $_SERVER['PHP_AUTH_DIGEST']
+ *
+ * @return array
+ */
+ public function getDigestAuth() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/http/RequestInterface.php b/ide/2.0.6/Phalcon/http/RequestInterface.php
new file mode 100644
index 000000000..c56f2d673
--- /dev/null
+++ b/ide/2.0.6/Phalcon/http/RequestInterface.php
@@ -0,0 +1,306 @@
+
+ * $response = new \Phalcon\Http\Response();
+ * $response->setStatusCode(200, "OK");
+ * $response->setContent("Hello");
+ * $response->send();
+ *
+ */
+class Response implements \Phalcon\Http\ResponseInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_sent = false;
+
+
+ protected $_content;
+
+
+ protected $_headers;
+
+
+ protected $_cookies;
+
+
+ protected $_file;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_statusCodes;
+
+
+ /**
+ * Phalcon\Http\Response constructor
+ *
+ * @param string $content
+ * @param int $code
+ * @param string $status
+ */
+ public function __construct($content = null, $code = null, $status = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the HTTP response code
+ *
+ * $response->setStatusCode(404, "Not Found");
+ *
+ *
+ * @param int $code
+ * @param string $message
+ * @return Response
+ */
+ public function setStatusCode($code, $message = null) {}
+
+ /**
+ * Returns the status code
+ *
+ * print_r($response->getStatusCode());
+ *
+ *
+ * @return array
+ */
+ public function getStatusCode() {}
+
+ /**
+ * Sets a headers bag for the response externally
+ *
+ * @param mixed $headers
+ * @return Response
+ */
+ public function setHeaders(\Phalcon\Http\Response\HeadersInterface $headers) {}
+
+ /**
+ * Returns headers set by the user
+ *
+ * @return \Phalcon\Http\Response\HeadersInterface
+ */
+ public function getHeaders() {}
+
+ /**
+ * Sets a cookies bag for the response externally
+ *
+ * @param mixed $cookies
+ * @return Response
+ */
+ public function setCookies(\Phalcon\Http\Response\CookiesInterface $cookies) {}
+
+ /**
+ * Returns coookies set by the user
+ *
+ * @return \Phalcon\Http\Response\CookiesInterface
+ */
+ public function getCookies() {}
+
+ /**
+ * Overwrites a header in the response
+ *
+ * $response->setHeader("Content-Type", "text/plain");
+ *
+ *
+ * @param string $name
+ * @param string $value
+ * @return \Phalcon\Http\Response
+ */
+ public function setHeader($name, $value) {}
+
+ /**
+ * Send a raw header to the response
+ *
+ * $response->setRawHeader("HTTP/1.1 404 Not Found");
+ *
+ *
+ * @param string $header
+ * @return Response
+ */
+ public function setRawHeader($header) {}
+
+ /**
+ * Resets all the stablished headers
+ *
+ * @return Response
+ */
+ public function resetHeaders() {}
+
+ /**
+ * Sets a Expires header to use HTTP cache
+ *
+ * $this->response->setExpires(new DateTime());
+ *
+ *
+ * @param mixed $datetime
+ * @return Response
+ */
+ public function setExpires(\DateTime $datetime) {}
+
+ /**
+ * Sets Cache headers to use HTTP cache
+ *
+ * $this->response->setCache(60);
+ *
+ *
+ * @param int $minutes
+ * @return Response
+ */
+ public function setCache($minutes) {}
+
+ /**
+ * Sends a Not-Modified response
+ *
+ * @return Response
+ */
+ public function setNotModified() {}
+
+ /**
+ * Sets the response content-type mime, optionally the charset
+ *
+ * $response->setContentType('application/pdf');
+ * $response->setContentType('text/plain', 'UTF-8');
+ *
+ *
+ * @param string $contentType
+ * @param string $charset
+ * @return \Phalcon\Http\Response
+ */
+ public function setContentType($contentType, $charset = null) {}
+
+ /**
+ * Set a custom ETag
+ *
+ * $response->setEtag(md5(time()));
+ *
+ *
+ * @param string $etag
+ * @return Response
+ */
+ public function setEtag($etag) {}
+
+ /**
+ * Redirect by HTTP to another action or URL
+ *
+ * //Using a string redirect (internal/external)
+ * $response->redirect("posts/index");
+ * $response->redirect("http://en.wikipedia.org", true);
+ * $response->redirect("http://www.example.com/new-location", true, 301);
+ * //Making a redirection based on a named route
+ * $response->redirect(array(
+ * "for" => "index-lang",
+ * "lang" => "jp",
+ * "controller" => "index"
+ * ));
+ *
+ *
+ * @param string|array $location
+ * @param boolean $externalRedirect
+ * @param int $statusCode
+ * @return \Phalcon\Http\Response
+ */
+ public function redirect($location = null, $externalRedirect = false, $statusCode = 302) {}
+
+ /**
+ * Sets HTTP response body
+ *
+ * response->setContent("Hello!
");
+ *
+ *
+ * @param string $content
+ * @return Response
+ */
+ public function setContent($content) {}
+
+ /**
+ * Sets HTTP response body. The parameter is automatically converted to JSON
+ *
+ * $response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param mixed $content
+ * @param int $jsonOptions
+ * @param mixed $depth
+ * @return \Phalcon\Http\Response
+ */
+ public function setJsonContent($content, $jsonOptions = 0, $depth = 512) {}
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\Response
+ */
+ public function appendContent($content) {}
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Check if the response is already sent
+ *
+ * @return bool
+ */
+ public function isSent() {}
+
+ /**
+ * Sends headers to the client
+ *
+ * @return Response
+ */
+ public function sendHeaders() {}
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return Response
+ */
+ public function sendCookies() {}
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return Response
+ */
+ public function send() {}
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @param mixed $attachment
+ * @return \Phalcon\Http\Response
+ */
+ public function setFileToSend($filePath, $attachmentName = null, $attachment = true) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/http/ResponseInterface.php b/ide/2.0.6/Phalcon/http/ResponseInterface.php
new file mode 100644
index 000000000..36f157f32
--- /dev/null
+++ b/ide/2.0.6/Phalcon/http/ResponseInterface.php
@@ -0,0 +1,150 @@
+
+ * response->setJsonContent(array("status" => "OK"));
+ *
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function setJsonContent($content);
+
+ /**
+ * Appends a string to the HTTP response body
+ *
+ * @param string $content
+ * @return \Phalcon\Http\ResponseInterface
+ */
+ public function appendContent($content);
+
+ /**
+ * Gets the HTTP response body
+ *
+ * @return string
+ */
+ public function getContent();
+
+ /**
+ * Sends headers to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendHeaders();
+
+ /**
+ * Sends cookies to the client
+ *
+ * @return ResponseInterface
+ */
+ public function sendCookies();
+
+ /**
+ * Prints out HTTP response to the client
+ *
+ * @return ResponseInterface
+ */
+ public function send();
+
+ /**
+ * Sets an attached file to be sent at the end of the request
+ *
+ * @param string $filePath
+ * @param string $attachmentName
+ * @return ResponseInterface
+ */
+ public function setFileToSend($filePath, $attachmentName = null);
+
+}
diff --git a/ide/2.0.6/Phalcon/http/cookie/Exception.php b/ide/2.0.6/Phalcon/http/cookie/Exception.php
new file mode 100644
index 000000000..a3dbbd67d
--- /dev/null
+++ b/ide/2.0.6/Phalcon/http/cookie/Exception.php
@@ -0,0 +1,12 @@
+
+ * class PostsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function uploadAction()
+ * {
+ * //Check if the user has uploaded files
+ * if ($this->request->hasFiles() == true) {
+ * //Print the real file names and their sizes
+ * foreach ($this->request->getUploadedFiles() as $file){
+ * echo $file->getName(), " ", $file->getSize(), "\n";
+ * }
+ * }
+ * }
+ * }
+ *
+ */
+class File implements \Phalcon\Http\Request\FileInterface
+{
+
+ protected $_name;
+
+
+ protected $_tmp;
+
+
+ protected $_size;
+
+
+ protected $_type;
+
+
+ protected $_realType;
+
+ /**
+ * @var string|null
+ */
+ protected $_error;
+
+ /**
+ * @var string|null
+ */
+ protected $_key;
+
+ /**
+ * @var string
+ */
+ protected $_extension;
+
+
+ /**
+ * @return string|null
+ */
+ public function getError() {}
+
+ /**
+ * @return string|null
+ */
+ public function getKey() {}
+
+ /**
+ * @return string
+ */
+ public function getExtension() {}
+
+ /**
+ * Phalcon\Http\Request\File constructor
+ *
+ * @param array $file
+ * @param mixed $key
+ */
+ public function __construct($file, $key = null) {}
+
+ /**
+ * Returns the file size of the uploaded file
+ *
+ * @return int
+ */
+ public function getSize() {}
+
+ /**
+ * Returns the real name of the uploaded file
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Returns the temporal name of the uploaded file
+ *
+ * @return string
+ */
+ public function getTempName() {}
+
+ /**
+ * Returns the mime type reported by the browser
+ * This mime type is not completely secure, use getRealType() instead
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Gets the real mime type of the upload file using finfo
+ *
+ * @return string
+ */
+ public function getRealType() {}
+
+ /**
+ * Checks whether the file has been uploaded via Post.
+ *
+ * @return bool
+ */
+ public function isUploadedFile() {}
+
+ /**
+ * Moves the temporary file to a destination within the application
+ *
+ * @param string $destination
+ * @return bool
+ */
+ public function moveTo($destination) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/http/request/FileInterface.php b/ide/2.0.6/Phalcon/http/request/FileInterface.php
new file mode 100644
index 000000000..3e3109e86
--- /dev/null
+++ b/ide/2.0.6/Phalcon/http/request/FileInterface.php
@@ -0,0 +1,64 @@
+
+ * $image = new Phalcon\Image\Adapter\Imagick("upload/test.jpg");
+ * $image->resize(200, 200)->rotate(90)->crop(100, 100);
+ * if ($image->save()) {
+ * echo 'success';
+ * }
+ *
+ */
+class Imagick extends \Phalcon\Image\Adapter implements \Phalcon\Image\AdapterInterface
+{
+
+ static protected $_version = 0;
+
+
+ static protected $_checked = false;
+
+
+ /**
+ * Checks if Imagick is enabled
+ *
+ * @return bool
+ */
+ public static function check() {}
+
+ /**
+ * \Phalcon\Image\Adapter\Imagick constructor
+ *
+ * @param string $file
+ * @param int $width
+ * @param int $height
+ */
+ public function __construct($file, $width = null, $height = null) {}
+
+ /**
+ * Execute a resize.
+ *
+ * @param int $width
+ * @param int $height
+ */
+ protected function _resize($width, $height) {}
+
+ /**
+ * This method scales the images using liquid rescaling method. Only support Imagick
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $deltaX
+ * @param int $rigidity
+ * @param int $$width new width
+ * @param int $$height new height
+ * @param int $$deltaX How much the seam can traverse on x-axis. Passing 0 causes the seams to be straight.
+ * @param int $$rigidity Introduces a bias for non-straight seams. This parameter is typically 0.
+ */
+ protected function _liquidRescale($width, $height, $deltaX, $rigidity) {}
+
+ /**
+ * Execute a crop.
+ *
+ * @param int $width
+ * @param int $height
+ * @param int $offsetX
+ * @param int $offsetY
+ */
+ protected function _crop($width, $height, $offsetX, $offsetY) {}
+
+ /**
+ * Execute a rotation.
+ *
+ * @param int $degrees
+ */
+ protected function _rotate($degrees) {}
+
+ /**
+ * Execute a flip.
+ *
+ * @param int $direction
+ */
+ protected function _flip($direction) {}
+
+ /**
+ * Execute a sharpen.
+ *
+ * @param int $amount
+ */
+ protected function _sharpen($amount) {}
+
+ /**
+ * Execute a reflection.
+ *
+ * @param int $height
+ * @param int $opacity
+ * @param bool $fadeIn
+ */
+ protected function _reflection($height, $opacity, $fadeIn) {}
+
+ /**
+ * Execute a watermarking.
+ *
+ * @param mixed $image
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ */
+ protected function _watermark(\Phalcon\Image\Adapter $image, $offsetX, $offsetY, $opacity) {}
+
+ /**
+ * Execute a text
+ *
+ * @param string $text
+ * @param int $offsetX
+ * @param int $offsetY
+ * @param int $opacity
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $size
+ * @param string $fontfile
+ */
+ protected function _text($text, $offsetX, $offsetY, $opacity, $r, $g, $b, $size, $fontfile) {}
+
+ /**
+ * Composite one image onto another
+ *
+ * @param mixed $image
+ * @param Adapter $$mask mask Image instance
+ */
+ protected function _mask(\Phalcon\Image\Adapter $image) {}
+
+ /**
+ * Execute a background.
+ *
+ * @param int $r
+ * @param int $g
+ * @param int $b
+ * @param int $opacity
+ */
+ protected function _background($r, $g, $b, $opacity) {}
+
+ /**
+ * Blur image
+ *
+ * @param int $radius
+ * @param int $$radius Blur radius
+ */
+ protected function _blur($radius) {}
+
+ /**
+ * Pixelate image
+ *
+ * @param int $amount
+ * @param int $$amount amount to pixelate
+ */
+ protected function _pixelate($amount) {}
+
+ /**
+ * Execute a save.
+ *
+ * @param string $file
+ * @param int $quality
+ */
+ protected function _save($file, $quality) {}
+
+ /**
+ * Execute a render.
+ *
+ * @param string $extension
+ * @param int $quality
+ * @return string
+ */
+ protected function _render($extension, $quality) {}
+
+ /**
+ * Destroys the loaded image to free up resources.
+ */
+ public function __destruct() {}
+
+ /**
+ * Get instance
+ *
+ * @return \Imagick
+ */
+ public function getInternalImInstance() {}
+
+ /**
+ * Sets the limit for a particular resource in megabytes
+ *
+ * @param int $type Refer to the list of resourcetype constants (@see http://php.net/manual/ru/imagick.constants.php#imagick.constants.resourcetypes.)
+ * @param int $limit The resource limit. The unit depends on the type of the resource being limited.
+ */
+ public function setResourceLimit($type, $limit) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/loader/Exception.php b/ide/2.0.6/Phalcon/loader/Exception.php
new file mode 100644
index 000000000..0732e2934
--- /dev/null
+++ b/ide/2.0.6/Phalcon/loader/Exception.php
@@ -0,0 +1,12 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\File("app/logs/test.log");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ * $logger->close();
+ *
+ */
+class File extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_fileHandler;
+
+ /**
+ * File Path
+ */
+ protected $_path;
+
+ /**
+ * Path options
+ */
+ protected $_options;
+
+
+ /**
+ * File Path
+ */
+ public function getPath() {}
+
+ /**
+ * Phalcon\Logger\Adapter\File constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the file itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * Opens the internal file handler after unserialization
+ */
+ public function __wakeup() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/logger/adapter/Firephp.php b/ide/2.0.6/Phalcon/logger/adapter/Firephp.php
new file mode 100644
index 000000000..8066f6805
--- /dev/null
+++ b/ide/2.0.6/Phalcon/logger/adapter/Firephp.php
@@ -0,0 +1,52 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Firephp("");
+ * $logger->log(\Phalcon\Logger::ERROR, "This is an error");
+ * $logger->error("This is another error");
+ *
+ */
+class Firephp extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ static private $_initialized;
+
+
+ static private $_index;
+
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @see http://www.firephp.org/Wiki/Reference/Protocol
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param string $$message
+ * @param int $$type
+ * @param int $$time
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/logger/adapter/Stream.php b/ide/2.0.6/Phalcon/logger/adapter/Stream.php
new file mode 100644
index 000000000..dd26d9015
--- /dev/null
+++ b/ide/2.0.6/Phalcon/logger/adapter/Stream.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Stream("php://stderr");
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Stream extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+ /**
+ * File handler resource
+ *
+ * @var resource
+ */
+ protected $_stream;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Stream constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\FormatterInterface
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return bool
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/logger/adapter/Syslog.php b/ide/2.0.6/Phalcon/logger/adapter/Syslog.php
new file mode 100644
index 000000000..cc0eb1569
--- /dev/null
+++ b/ide/2.0.6/Phalcon/logger/adapter/Syslog.php
@@ -0,0 +1,57 @@
+
+ * $logger = new \Phalcon\Logger\Adapter\Syslog("ident", array(
+ * 'option' => LOG_NDELAY,
+ * 'facility' => LOG_MAIL
+ * ));
+ * $logger->log("This is a message");
+ * $logger->log("This is an error", \Phalcon\Logger::ERROR);
+ * $logger->error("This is another error");
+ *
+ */
+class Syslog extends \Phalcon\Logger\Adapter implements \Phalcon\Logger\AdapterInterface
+{
+
+ protected $_opened = false;
+
+
+ /**
+ * Phalcon\Logger\Adapter\Syslog constructor
+ *
+ * @param string $name
+ * @param array $options
+ */
+ public function __construct($name, $options = null) {}
+
+ /**
+ * Returns the internal formatter
+ *
+ * @return \Phalcon\Logger\Formatter\Syslog
+ */
+ public function getFormatter() {}
+
+ /**
+ * Writes the log to the stream itself
+ *
+ * @param string $message
+ * @param int $type
+ * @param int $time
+ * @param array $context
+ * @param array $$context
+ */
+ public function logInternal($message, $type, $time, $context) {}
+
+ /**
+ * Closes the logger
+ *
+ * @return boolean
+ */
+ public function close() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/logger/formatter/Firephp.php b/ide/2.0.6/Phalcon/logger/formatter/Firephp.php
new file mode 100644
index 000000000..567c7aee9
--- /dev/null
+++ b/ide/2.0.6/Phalcon/logger/formatter/Firephp.php
@@ -0,0 +1,71 @@
+
+ * class Application extends \Phalcon\Mvc\Application
+ * {
+ * /
+ * Register the services here to make them general or register
+ * in the ModuleDefinition to make them module-specific
+ * \/
+ * protected function _registerServices()
+ * {
+ * }
+ * /
+ * This method registers all the modules in the application
+ * \/
+ * public function main()
+ * {
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ * }
+ * }
+ * $application = new Application();
+ * $application->main();
+ *
+ */
+class Application extends \Phalcon\Di\Injectable
+{
+
+ protected $_defaultModule;
+
+
+ protected $_modules;
+
+
+ protected $_implicitView = true;
+
+
+ /**
+ * Phalcon\Mvc\Application
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * By default. The view is implicitly buffering all the output
+ * You can full disable the view component using this method
+ *
+ * @param bool $implicitView
+ * @return Application
+ */
+ public function useImplicitView($implicitView) {}
+
+ /**
+ * Register an array of modules present in the application
+ *
+ * $this->registerModules(array(
+ * 'frontend' => array(
+ * 'className' => 'Multiple\Frontend\Module',
+ * 'path' => '../apps/frontend/Module.php'
+ * ),
+ * 'backend' => array(
+ * 'className' => 'Multiple\Backend\Module',
+ * 'path' => '../apps/backend/Module.php'
+ * )
+ * ));
+ *
+ *
+ * @param array $modules
+ * @param bool $merge
+ * @return Application
+ */
+ public function registerModules($modules, $merge = false) {}
+
+ /**
+ * Return the modules registered in the application
+ *
+ * @return array
+ */
+ public function getModules() {}
+
+ /**
+ * Gets the module definition registered in the application via module name
+ *
+ * @param string $name
+ * @return array|object
+ */
+ public function getModule($name) {}
+
+ /**
+ * Sets the module name to be used if the router doesn't return a valid module
+ *
+ * @param string $defaultModule
+ * @return Application
+ */
+ public function setDefaultModule($defaultModule) {}
+
+ /**
+ * Returns the default module name
+ *
+ * @return string
+ */
+ public function getDefaultModule() {}
+
+ /**
+ * Handles a MVC request
+ *
+ * @param string $uri
+ * @return \Phalcon\Http\ResponseInterface|boolean
+ */
+ public function handle($uri = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/Collection.php b/ide/2.0.6/Phalcon/mvc/Collection.php
new file mode 100644
index 000000000..53b3a5f2e
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/Collection.php
@@ -0,0 +1,509 @@
+
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns a cloned collection
+ *
+ * @param mixed $collection
+ * @param array $document
+ * @return CollectionInterface
+ */
+ public static function cloneResult(CollectionInterface $collection, $document) {}
+
+ /**
+ * Returns a collection resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @param boolean $unique
+ * @return array
+ */
+ protected static function _getResultset($params, CollectionInterface $collection, $connection, $unique) {}
+
+ /**
+ * Perform a count over a resultset
+ *
+ * @param array $params
+ * @param \Phalcon\Mvc\Collection $collection
+ * @param \MongoDb $connection
+ * @return int
+ */
+ protected static function _getGroupResultset($params, Collection $collection, $connection) {}
+
+ /**
+ * Executes internal hooks before save a document
+ *
+ * @param \Phalcon\DiInterface $dependencyInjector
+ * @param boolean $disableEvents
+ * @param boolean $exists
+ * @return boolean
+ */
+ protected final function _preSave($dependencyInjector, $disableEvents, $exists) {}
+
+ /**
+ * Executes internal events after save a document
+ *
+ * @param bool $disableEvents
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected final function _postSave($disableEvents, $success, $exists) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Collection
+ * {
+ * public function validation()
+ * {
+ * this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if (this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Fires an internal event
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an internal event that cancels the operation
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ *
+ * @param bool $disableEvents
+ * @return bool
+ */
+ protected function _cancelOperation($disableEvents) {}
+
+ /**
+ * Checks if the document exists in the collection
+ *
+ * @param \MongoCollection $collection
+ * @return boolean
+ */
+ protected function _exists($collection) {}
+
+ /**
+ * Returns all the validation messages
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if ($this->name == 'Peter') {
+ * message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Creates/Updates a collection based on the values in the attributes
+ *
+ * @return bool
+ */
+ public function save() {}
+
+ /**
+ * Find a document by its id (_id)
+ *
+ * @param string|\MongoId $id
+ * @return \Phalcon\Mvc\Collection
+ */
+ public static function findById($id) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in the robots table?
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name, "\n";
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "The first mechanical robot name is ", $robot->name, "\n";
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array(
+ * array("type" => "mechanical"),
+ * "order" => array("name" => 1)
+ * ));
+ * echo "The first virtual robot name is ", $robot->name, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ * //How many mechanical robots are there?
+ * $robots = Robots::find(array(
+ * array("type" => "mechanical")
+ * ));
+ * echo "There are ", count(robots), "\n";
+ * //Get and print virtual robots ordered by name
+ * $robots = Robots::findFirst(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1)
+ * ));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array(
+ * array("type" => "virtual"),
+ * "order" => array("name" => 1),
+ * "limit" => 100
+ * ));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Perform a count over a collection
+ *
+ * echo 'There are ', Robots::count(), ' robots';
+ *
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Perform an aggregation using the Mongo aggregation framework
+ *
+ * @param array $parameters
+ * @return array
+ */
+ public static function aggregate($parameters = null) {}
+
+ /**
+ * Allows to perform a summatory group for a column in the collection
+ *
+ * @param string $field
+ * @param mixed $conditions
+ * @param mixed $finalize
+ * @return array
+ */
+ public static function summatory($field, $conditions = null, $finalize = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ * $robot = Robots::findFirst();
+ * $robot->delete();
+ * foreach (Robots::find() as $robot) {
+ * $robot->delete();
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+ * Sets up a behavior in a collection
+ *
+ * @param mixed $behavior
+ */
+ protected function addBehavior(\Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r($robot->toArray());
+ *
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+ /**
+ * Serializes the object ignoring connections or protected properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/CollectionInterface.php b/ide/2.0.6/Phalcon/mvc/CollectionInterface.php
new file mode 100644
index 000000000..f72bb909f
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/CollectionInterface.php
@@ -0,0 +1,148 @@
+
+ * dispatcher->forward(array('controller' => 'people', 'action' => 'index'));
+ * }
+ * }
+ *
+ */
+abstract class Controller extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ControllerInterface
+{
+
+ /**
+ * Phalcon\Mvc\Controller constructor
+ */
+ public final function __construct() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/ControllerInterface.php b/ide/2.0.6/Phalcon/mvc/ControllerInterface.php
new file mode 100644
index 000000000..a46083149
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/ControllerInterface.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $dispatcher = new \Phalcon\Mvc\Dispatcher();
+ * $dispatcher->setDI($di);
+ * $dispatcher->setControllerName('posts');
+ * $dispatcher->setActionName('index');
+ * $dispatcher->setParams(array());
+ * $controller = $dispatcher->dispatch();
+ *
+ */
+class Dispatcher extends \Phalcon\Dispatcher implements \Phalcon\Mvc\DispatcherInterface
+{
+
+ protected $_handlerSuffix = "Controller";
+
+
+ protected $_defaultHandler = "index";
+
+
+ protected $_defaultAction = "index";
+
+
+ /**
+ * Sets the default controller suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the controller name to be dispatched
+ *
+ * @param string $controllerName
+ */
+ public function setControllerName($controllerName) {}
+
+ /**
+ * Gets last dispatched controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets previous dispatched controller name
+ *
+ * @return string
+ */
+ public function getPreviousControllerName() {}
+
+ /**
+ * Gets previous dispatched action name
+ *
+ * @return string
+ */
+ public function getPreviousActionName() {}
+
+ /**
+ * Throws an internal exception
+ *
+ * @param string $message
+ * @param int $exceptionCode
+ */
+ protected function _throwDispatchException($message, $exceptionCode = 0) {}
+
+ /**
+ * Handles a user exception
+ *
+ * @param mixed $exception
+ */
+ protected function _handleException(\Exception $exception) {}
+
+ /**
+ * Possible controller class name that will be located to dispatch the request
+ *
+ * @return string
+ */
+ public function getControllerClass() {}
+
+ /**
+ * Returns the lastest dispatched controller
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getLastController() {}
+
+ /**
+ * Returns the active controller in the dispatcher
+ *
+ * @return \Phalcon\Mvc\ControllerInterface
+ */
+ public function getActiveController() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/DispatcherInterface.php b/ide/2.0.6/Phalcon/mvc/DispatcherInterface.php
new file mode 100644
index 000000000..d232517a7
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/DispatcherInterface.php
@@ -0,0 +1,54 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $app->get('/say/welcome/{name}', function ($name) {
+ * echo "
+ * $app['request'] = new \Phalcon\Http\Request();
+ *
+ *
+ * @param string $alias
+ * @param mixed $definition
+ */
+ public function offsetSet($alias, $definition) {}
+
+ /**
+ * Allows to obtain a shared service in the internal services container using the array syntax
+ *
+ * var_dump($di['request']);
+ *
+ *
+ * @param string $alias
+ * @return mixed
+ */
+ public function offsetGet($alias) {}
+
+ /**
+ * Removes a service from the internal services container using the array syntax
+ *
+ * @param string $alias
+ */
+ public function offsetUnset($alias) {}
+
+ /**
+ * Appends a before middleware to be called before execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function before($handler) {}
+
+ /**
+ * Appends an 'after' middleware to be called after execute the route
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function after($handler) {}
+
+ /**
+ * Appends a 'finish' middleware to be called when the request is finished
+ *
+ * @param callable $handler
+ * @return \Phalcon\Mvc\Micro
+ */
+ public function finish($handler) {}
+
+ /**
+ * Returns the internal handlers attached to the application
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/Model.php b/ide/2.0.6/Phalcon/mvc/Model.php
new file mode 100644
index 000000000..584ae0ba5
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/Model.php
@@ -0,0 +1,1192 @@
+
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can store robots: ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ */
+abstract class Model implements \Phalcon\Mvc\EntityInterface, \Phalcon\Mvc\ModelInterface, \Phalcon\Mvc\Model\ResultInterface, \Phalcon\Di\InjectionAwareInterface, \Serializable
+{
+
+ const OP_NONE = 0;
+
+
+ const OP_CREATE = 1;
+
+
+ const OP_UPDATE = 2;
+
+
+ const OP_DELETE = 3;
+
+
+ const DIRTY_STATE_PERSISTENT = 0;
+
+
+ const DIRTY_STATE_TRANSIENT = 1;
+
+
+ const DIRTY_STATE_DETACHED = 2;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_modelsManager;
+
+
+ protected $_modelsMetaData;
+
+
+ protected $_errorMessages;
+
+
+ protected $_operationMade = 0;
+
+
+ protected $_dirtyState = 1;
+
+
+ protected $_transaction;
+
+
+ protected $_uniqueKey;
+
+
+ protected $_uniqueParams;
+
+
+ protected $_uniqueTypes;
+
+
+ protected $_skipped;
+
+
+ protected $_related;
+
+
+ protected $_snapshot;
+
+
+ /**
+ * Phalcon\Mvc\Model constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param mixed $modelsManager
+ */
+ public final function __construct(\Phalcon\DiInterface $dependencyInjector = null, \Phalcon\Mvc\Model\ManagerInterface $modelsManager = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a custom events manager
+ *
+ * @param mixed $eventsManager
+ */
+ protected function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the custom events manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ protected function getEventsManager() {}
+
+ /**
+ * Returns the models meta-data service related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\MetaDataInterface
+ */
+ public function getModelsMetaData() {}
+
+ /**
+ * Returns the models manager related to the entity instance
+ *
+ * @return \Phalcon\Mvc\Model\ManagerInterface
+ */
+ public function getModelsManager() {}
+
+ /**
+ * Sets a transaction related to the Model instance
+ *
+ * use Phalcon\Mvc\Model\Transaction\Manager as TxManager;
+ * use Phalcon\Mvc\Model\Transaction\Failed as TxFailed;
+ * try {
+ * $txManager = new TxManager();
+ * $transaction = $txManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Robot part cannot be saved");
+ * }
+ * $transaction->commit();
+ * } catch (TxFailed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ *
+ * @param mixed $transaction
+ * @return Model
+ */
+ public function setTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Sets table name which model should be mapped
+ *
+ * @param string $source
+ * @return Model
+ */
+ protected function setSource($source) {}
+
+ /**
+ * Returns table name mapped in the model
+ *
+ * @return string
+ */
+ public function getSource() {}
+
+ /**
+ * Sets schema name where table mapped is located
+ *
+ * @param string $schema
+ * @return Model
+ */
+ protected function setSchema($schema) {}
+
+ /**
+ * Returns schema name where table mapped is located
+ *
+ * @return string
+ */
+ public function getSchema() {}
+
+ /**
+ * Sets the DependencyInjection connection service name
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to read data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setReadConnectionService($connectionService) {}
+
+ /**
+ * Sets the DependencyInjection connection service name used to write data
+ *
+ * @param string $connectionService
+ * @return Model
+ */
+ public function setWriteConnectionService($connectionService) {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to read data related the model
+ *
+ * @return string
+ */
+ public function getReadConnectionService() {}
+
+ /**
+ * Returns the DependencyInjection connection service name used to write data related to the model
+ *
+ * @return string
+ */
+ public function getWriteConnectionService() {}
+
+ /**
+ * Sets the dirty state of the object using one of the DIRTY_STATE_* constants
+ *
+ * @param int $dirtyState
+ * @return ModelInterface
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Returns one of the DIRTY_STATE_* constants telling if the record exists in the database or not
+ *
+ * @return int
+ */
+ public function getDirtyState() {}
+
+ /**
+ * Gets the connection used to read data for the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection() {}
+
+ /**
+ * Gets the connection used to write data to the model
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection() {}
+
+ /**
+ * Assigns values to a model from an array
+ *
+ * $robot->assign(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ * //assign by db row, column map needed
+ * $robot->assign($dbRow, array(
+ * 'db_type' => 'type',
+ * 'db_name' => 'name',
+ * 'db_year' => 'year'
+ * ));
+ * //allow assign only name and year
+ * $robot->assign($_POST, null, array('name', 'year');
+ *
+ *
+ * @param array $data
+ * @param array $dataColumnMap array to transform keys of data to another
+ * @param array $whiteList
+ * @return \Phalcon\Mvc\Model
+ */
+ public function assign($data, $dataColumnMap = null, $whiteList = null) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model.
+ *
+ * $robot = \Phalcon\Mvc\Model::cloneResultMap(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface|Phalcon\Mvc\Model\Row $base
+ * @param array $data
+ * @param array $columnMap
+ * @param int $dirtyState
+ * @param boolean $keepSnapshots
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function cloneResultMap($base, $data, $columnMap, $dirtyState = 0, $keepSnapshots = null) {}
+
+ /**
+ * Returns an hydrated result based on the data and the column map
+ *
+ * @param array $data
+ * @param array $columnMap
+ * @param int $hydrationMode
+ * @return mixed
+ */
+ public static function cloneResultMapHydrate($data, $columnMap, $hydrationMode) {}
+
+ /**
+ * Assigns values to a model from an array returning a new model
+ *
+ * $robot = Phalcon\Mvc\Model::cloneResult(new Robots(), array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astro Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param mixed $base
+ * @param array $data
+ * @param int $dirtyState
+ * @param \Phalcon\Mvc\ModelInterface $$base
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public static function cloneResult(ModelInterface $base, $data, $dirtyState = 0) {}
+
+ /**
+ * Allows to query a set of records that match the specified conditions
+ *
+ * //How many robots are there?
+ * $robots = Robots::find();
+ * echo "There are ", count($robots), "\n";
+ * //How many mechanical robots are there?
+ * $robots = Robots::find("type='mechanical'");
+ * echo "There are ", count($robots), "\n";
+ * //Get and print virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ * //Get first 100 virtual robots ordered by name
+ * $robots = Robots::find(array("type='virtual'", "order" => "name", "limit" => 100));
+ * foreach ($robots as $robot) {
+ * echo $robot->name, "\n";
+ * }
+ *
+ *
+ * @param mixed $parameters
+ * @param $array parameters
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public static function find($parameters = null) {}
+
+ /**
+ * Allows to query the first record that match the specified conditions
+ *
+ * //What's the first robot in robots table?
+ * $robot = Robots::findFirst();
+ * echo "The robot name is ", $robot->name;
+ * //What's the first mechanical robot in robots table?
+ * $robot = Robots::findFirst("type='mechanical'");
+ * echo "The first mechanical robot name is ", $robot->name;
+ * //Get first virtual robot ordered by name
+ * $robot = Robots::findFirst(array("type='virtual'", "order" => "name"));
+ * echo "The first virtual robot name is ", $robot->name;
+ *
+ *
+ * @param string|array $parameters
+ * @return \Phalcon\Mvc\Model
+ */
+ public static function findFirst($parameters = null) {}
+
+ /**
+ * Create a criteria for a specific model
+ *
+ * @param mixed $dependencyInjector
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public static function query(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Checks if the current record already exists or not
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _exists(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table = null) {}
+
+ /**
+ * Generate a PHQL SELECT statement for an aggregate
+ *
+ * @param string $functionName
+ * @param string $alias
+ * @param array $parameters
+ * @param string $function
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected static function _groupResult($functionName, $alias, $parameters) {}
+
+ /**
+ * Allows to count how many records match the specified conditions
+ *
+ * //How many robots are there?
+ * $number = Robots::count();
+ * echo "There are ", $number, "\n";
+ * //How many mechanical robots are there?
+ * $number = Robots::count("type='mechanical'");
+ * echo "There are ", $number, " mechanical robots\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function count($parameters = null) {}
+
+ /**
+ * Allows to calculate a summatory on a column that match the specified conditions
+ *
+ * //How much are all robots?
+ * $sum = Robots::sum(array('column' => 'price'));
+ * echo "The total price of robots is ", $sum, "\n";
+ * //How much are mechanical robots?
+ * $sum = Robots::sum(array("type='mechanical'", 'column' => 'price'));
+ * echo "The total price of mechanical robots is ", $sum, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function sum($parameters = null) {}
+
+ /**
+ * Allows to get the maximum value of a column that match the specified conditions
+ *
+ * //What is the maximum robot id?
+ * $id = Robots::maximum(array('column' => 'id'));
+ * echo "The maximum robot id is: ", $id, "\n";
+ * //What is the maximum id of mechanical robots?
+ * $sum = Robots::maximum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The maximum robot id of mechanical robots is ", $id, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function maximum($parameters = null) {}
+
+ /**
+ * Allows to get the minimum value of a column that match the specified conditions
+ *
+ * //What is the minimum robot id?
+ * $id = Robots::minimum(array('column' => 'id'));
+ * echo "The minimum robot id is: ", $id;
+ * //What is the minimum id of mechanical robots?
+ * $sum = Robots::minimum(array("type='mechanical'", 'column' => 'id'));
+ * echo "The minimum robot id of mechanical robots is ", $id;
+ *
+ *
+ * @param array $parameters
+ * @return mixed
+ */
+ public static function minimum($parameters = null) {}
+
+ /**
+ * Allows to calculate the average value on a column matching the specified conditions
+ *
+ * //What's the average price of robots?
+ * $average = Robots::average(array('column' => 'price'));
+ * echo "The average price is ", $average, "\n";
+ * //What's the average price of mechanical robots?
+ * $average = Robots::average(array("type='mechanical'", 'column' => 'price'));
+ * echo "The average price of mechanical robots is ", $average, "\n";
+ *
+ *
+ * @param array $parameters
+ * @return double
+ */
+ public static function average($parameters = null) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEvent($eventName) {}
+
+ /**
+ * Fires an event, implicitly calls behaviors and listeners in the events manager are notified
+ * This method stops if one of the callbacks/listeners returns boolean false
+ *
+ * @param string $eventName
+ * @return bool
+ */
+ public function fireEventCancel($eventName) {}
+
+ /**
+ * Cancel the current operation
+ */
+ protected function _cancelOperation() {}
+
+ /**
+ * Appends a customized message on the validation process
+ *
+ * use \Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if ($this->name == 'Peter') {
+ * $message = new Message("Sorry, but a robot cannot be named Peter");
+ * $this->appendMessage($message);
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $message
+ * @return Model
+ */
+ public function appendMessage(\Phalcon\Mvc\Model\MessageInterface $message) {}
+
+ /**
+ * Executes validators on every validation call
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @param mixed $validator
+ * @return Model
+ */
+ protected function validate(Model\ValidatorInterface $validator) {}
+
+ /**
+ * Check whether validation process has generated any messages
+ *
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionIn;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionIn(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function validationHasFailed() {}
+
+ /**
+ * Returns all the validation messages
+ *
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * if ($robot->save() == false) {
+ * echo "Umh, We can't store robots right now ";
+ * foreach ($robot->getMessages() as $message) {
+ * echo $message;
+ * }
+ * } else {
+ * echo "Great, a new robot was saved successfully!";
+ * }
+ *
+ *
+ * @param mixed $filter
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages($filter = null) {}
+
+ /**
+ * Reads "belongs to" relations and check the virtual foreign keys when inserting or updating records
+ * to verify that inserted/updated values are present in the related entity
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysRestrict() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (cascade) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseCascade() {}
+
+ /**
+ * Reads both "hasMany" and "hasOne" relations and checks the virtual foreign keys (restrict) when deleting records
+ *
+ * @return bool
+ */
+ protected function _checkForeignKeysReverseRestrict() {}
+
+ /**
+ * Executes internal hooks before save a record
+ *
+ * @param mixed $metaData
+ * @param bool $exists
+ * @param mixed $identityField
+ * @return bool
+ */
+ protected function _preSave(\Phalcon\Mvc\Model\MetadataInterface $metaData, $exists, $identityField) {}
+
+ /**
+ * Executes internal events after save a record
+ *
+ * @param bool $success
+ * @param bool $exists
+ * @return bool
+ */
+ protected function _postSave($success, $exists) {}
+
+ /**
+ * Sends a pre-build INSERT SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetadataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @param boolean|string $identityField
+ * @return boolean
+ */
+ protected function _doLowInsert(\Phalcon\Mvc\Model\MetadataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table, $identityField) {}
+
+ /**
+ * Sends a pre-build UPDATE SQL statement to the relational database system
+ *
+ * @param \Phalcon\Mvc\Model\MetaDataInterface $metaData
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param string|array $table
+ * @return boolean
+ */
+ protected function _doLowUpdate(\Phalcon\Mvc\Model\MetaDataInterface $metaData, \Phalcon\Db\AdapterInterface $connection, $table) {}
+
+ /**
+ * Saves related records that must be stored prior to save the master record
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _preSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Save the related records assigned in the has-one/has-many relations
+ *
+ * @param \Phalcon\Db\AdapterInterface $connection
+ * @param \Phalcon\Mvc\ModelInterface[] $related
+ * @return boolean
+ */
+ protected function _postSaveRelatedRecords(\Phalcon\Db\AdapterInterface $connection, $related) {}
+
+ /**
+ * Inserts or updates a model instance. Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->save();
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->save();
+ *
+ *
+ * @param array $data
+ * @param array $whiteList
+ * @return boolean
+ */
+ public function save($data = null, $whiteList = null) {}
+
+ /**
+ * Inserts a model instance. If the instance already exists in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Creating a new robot
+ * $robot = new Robots();
+ * $robot->type = 'mechanical';
+ * $robot->name = 'Astro Boy';
+ * $robot->year = 1952;
+ * $robot->create();
+ * //Passing an array to create
+ * $robot = new Robots();
+ * $robot->create(array(
+ * 'type' => 'mechanical',
+ * 'name' => 'Astroy Boy',
+ * 'year' => 1952
+ * ));
+ *
+ *
+ * @param mixed $data
+ * @param mixed $whiteList
+ * @return bool
+ */
+ public function create($data = null, $whiteList = null) {}
+
+ /**
+ * Updates a model instance. If the instance doesn't exist in the persistance it will throw an exception
+ * Returning true on success or false otherwise.
+ *
+ * //Updating a robot name
+ * $robot = Robots::findFirst("id=100");
+ * $robot->name = "Biomass";
+ * $robot->update();
+ *
+ *
+ * @param mixed $data
+ * @param mixed $whiteList
+ * @return bool
+ */
+ public function update($data = null, $whiteList = null) {}
+
+ /**
+ * Deletes a model instance. Returning true on success or false otherwise.
+ *
+ * $robot = Robots::findFirst("id=100");
+ * $robot->delete();
+ * foreach (Robots::find("type = 'mechanical'") as $robot) {
+ * $robot->delete();
+ * }
+ *
+ *
+ * @return bool
+ */
+ public function delete() {}
+
+ /**
+ * Returns the type of the latest operation performed by the ORM
+ * Returns one of the OP_* class constants
+ *
+ * @return int
+ */
+ public function getOperationMade() {}
+
+ /**
+ * Refreshes the model attributes re-querying the record from the database
+ *
+ * @return Model
+ */
+ public function refresh() {}
+
+ /**
+ * Skips the current operation forcing a success state
+ *
+ * @param bool $skip
+ */
+ public function skipOperation($skip) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT/UPDATE statement
+ *
+ * skipAttributes(array('price'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributes($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated INSERT statement
+ *
+ * skipAttributesOnCreate(array('created_at'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnCreate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * skipAttributesOnUpdate(array('modified_in'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function skipAttributesOnUpdate($attributes) {}
+
+ /**
+ * Sets a list of attributes that must be skipped from the
+ * generated UPDATE statement
+ *
+ * allowEmptyStringValues(array('name'));
+ * }
+ * }
+ *
+ *
+ * @param array $attributes
+ */
+ protected function allowEmptyStringValues($attributes) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * hasOne('id', 'RobotsDescription', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasOne($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse 1-1 between two models
+ *
+ * belongsTo('robots_id', 'Robots', 'id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function belongsTo($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * hasMany('id', 'RobotsParts', 'robots_id');
+ * }
+ * }
+ *
+ *
+ * @param mixed $fields
+ * @param string $referenceModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasMany($fields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation n-n between two models through an intermediate relation
+ *
+ * hasManyToMany(
+ * 'id',
+ * 'RobotsParts',
+ * 'robots_id',
+ * 'parts_id',
+ * 'Parts',
+ * 'id'
+ * );
+ * }
+ * }
+ *
+ *
+ * @param string|array fields
+ * @param string intermediateModel
+ * @param string|array intermediateFields
+ * @param string|array intermediateReferencedFields
+ * @param string referencedModel
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referenceModel
+ * @param string|array $referencedFields
+ * @param array $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ protected function hasManyToMany($fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referenceModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a behavior in a model
+ *
+ * addBehavior(new Timestampable(array(
+ * 'onCreate' => array(
+ * 'field' => 'created_at',
+ * 'format' => 'Y-m-d'
+ * )
+ * )));
+ * }
+ * }
+ *
+ *
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if the model must keep the original record snapshot in memory
+ *
+ * keepSnapshots(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $keepSnapshot
+ */
+ protected function keepSnapshots($keepSnapshot) {}
+
+ /**
+ * Sets the record's snapshot data.
+ * This method is used internally to set snapshot data when the model was set up to keep snapshot data
+ *
+ * @param array $data
+ * @param array $columnMap
+ */
+ public function setSnapshotData($data, $columnMap = null) {}
+
+ /**
+ * Checks if the object has internal snapshot data
+ *
+ * @return bool
+ */
+ public function hasSnapshotData() {}
+
+ /**
+ * Returns the internal snapshot data
+ *
+ * @return array
+ */
+ public function getSnapshotData() {}
+
+ /**
+ * Check if a specific attribute has changed
+ * This only works if the model is keeping data snapshots
+ *
+ * @param string|array $fieldName
+ * @return bool
+ */
+ public function hasChanged($fieldName = null) {}
+
+ /**
+ * Returns a list of changed values
+ *
+ * @return array
+ */
+ public function getChangedFields() {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * useDynamicUpdate(true);
+ * }
+ * }
+ *
+ *
+ * @param bool $dynamicUpdate
+ */
+ protected function useDynamicUpdate($dynamicUpdate) {}
+
+ /**
+ * Returns related records based on defined relations
+ *
+ * @param string $alias
+ * @param array $arguments
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getRelated($alias, $arguments = null) {}
+
+ /**
+ * Returns related records defined relations depending on the method name
+ *
+ * @param string $modelName
+ * @param string $method
+ * @param array $arguments
+ * @return mixed
+ */
+ protected function _getRelatedRecords($modelName, $method, $arguments) {}
+
+ /**
+ * Handles method calls when a method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+ public function __call($method, $arguments) {}
+
+ /**
+ * Handles method calls when a static method is not implemented
+ *
+ * @param string method
+ * @param array arguments
+ * @return mixed
+ * @param string $method
+ * @param mixed $arguments
+ */
+ public static function __callStatic($method, $arguments = null) {}
+
+ /**
+ * Magic method to assign values to the the model
+ *
+ * @param string $property
+ * @param mixed $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Magic method to get related records using the relation alias as a property
+ *
+ * @param string $property
+ * @return \Phalcon\Mvc\Model\Resultset|Phalcon\Mvc\Model
+ */
+ public function __get($property) {}
+
+ /**
+ * Magic method to check if a property is a valid relation
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Serializes the object ignoring connections, services, related objects or static properties
+ *
+ * @return string
+ */
+ public function serialize() {}
+
+ /**
+ * Unserializes the object from a serialized string
+ *
+ * @param string $data
+ */
+ public function unserialize($data) {}
+
+ /**
+ * Returns a simple representation of the object that can be used with var_dump
+ *
+ * var_dump($robot->dump());
+ *
+ *
+ * @return array
+ */
+ public function dump() {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * print_r($robot->toArray());
+ *
+ *
+ * @param mixed $columns
+ * @param array $$columns
+ * @return array
+ */
+ public function toArray($columns = null) {}
+
+ /**
+ * Enables/disables options in the ORM
+ *
+ * @param array $options
+ */
+ public static function setup($options) {}
+
+ /**
+ * Reset a model instance data
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/ModelInterface.php b/ide/2.0.6/Phalcon/mvc/ModelInterface.php
new file mode 100644
index 000000000..4a24901de
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/ModelInterface.php
@@ -0,0 +1,323 @@
+
+ * $router = new Router();
+ * $router->add(
+ * "/documentation/{chapter}/{name}\.{type:[a-z]+}",
+ * array(
+ * "controller" => "documentation",
+ * "action" => "show"
+ * )
+ * );
+ * $router->handle();
+ * echo $router->getControllerName();
+ *
+ */
+class Router implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Mvc\RouterInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ const URI_SOURCE_GET_URL = 0;
+
+
+ const URI_SOURCE_SERVER_REQUEST_URI = 1;
+
+
+ const POSITION_FIRST = 0;
+
+
+ const POSITION_LAST = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_eventsManager;
+
+
+ protected $_uriSource;
+
+
+ protected $_namespace = null;
+
+
+ protected $_module = null;
+
+
+ protected $_controller = null;
+
+
+ protected $_action = null;
+
+
+ protected $_params;
+
+
+ protected $_routes;
+
+
+ protected $_matchedRoute;
+
+
+ protected $_matches;
+
+
+ protected $_wasMatched = false;
+
+
+ protected $_defaultNamespace;
+
+
+ protected $_defaultModule;
+
+
+ protected $_defaultController;
+
+
+ protected $_defaultAction;
+
+
+ protected $_defaultParams;
+
+
+ protected $_removeExtraSlashes;
+
+
+ protected $_notFoundPaths;
+
+
+ /**
+ * Phalcon\Mvc\Router constructor
+ *
+ * @param bool $defaultRoutes
+ */
+ public function __construct($defaultRoutes = true) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the events manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Get rewrite info. This info is read from $_GET['_url']. This returns '/' if the rewrite information cannot be read
+ *
+ * @return string
+ */
+ public function getRewriteUri() {}
+
+ /**
+ * Sets the URI source. One of the URI_SOURCE_* constants
+ *
+ * $router->setUriSource(Router::URI_SOURCE_SERVER_REQUEST_URI);
+ *
+ *
+ * @param mixed $uriSource
+ * @return RouterInterface
+ */
+ public function setUriSource($uriSource) {}
+
+ /**
+ * Set whether router must remove the extra slashes in the handled routes
+ *
+ * @param bool $remove
+ * @return RouterInterface
+ */
+ public function removeExtraSlashes($remove) {}
+
+ /**
+ * Sets the name of the default namespace
+ *
+ * @param string $namespaceName
+ * @return RouterInterface
+ */
+ public function setDefaultNamespace($namespaceName) {}
+
+ /**
+ * Sets the name of the default module
+ *
+ * @param string $moduleName
+ * @return RouterInterface
+ */
+ public function setDefaultModule($moduleName) {}
+
+ /**
+ * Sets the default controller name
+ *
+ * @param string $controllerName
+ * @return RouterInterface
+ */
+ public function setDefaultController($controllerName) {}
+
+ /**
+ * Sets the default action name
+ *
+ * @param string $actionName
+ * @return RouterInterface
+ */
+ public function setDefaultAction($actionName) {}
+
+ /**
+ * Sets an array of default paths. If a route is missing a path the router will use the defined here
+ * This method must not be used to set a 404 route
+ *
+ * $router->setDefaults(array(
+ * 'module' => 'common',
+ * 'action' => 'index'
+ * ));
+ *
+ *
+ * @param array $defaults
+ * @return RouterInterface
+ */
+ public function setDefaults($defaults) {}
+
+ /**
+ * Returns an array of default parameters
+ *
+ * @return array
+ */
+ public function getDefaults() {}
+
+ /**
+ * Handles routing information received from the rewrite engine
+ *
+ * //Read the info from the rewrite engine
+ * $router->handle();
+ * //Manually passing an URL
+ * $router->handle('/posts/edit/1');
+ *
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Adds a route to the router without any HTTP constraint
+ *
+ * use Phalcon\Mvc\Router;
+ * $router->add('/about', 'About::index');
+ * $router->add('/about', 'About::index', ['GET', 'POST']);
+ * $router->add('/about', 'About::index', ['GET', 'POST'], Router::POSITION_FIRST);
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $position
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null, $position = Router::POSITION_LAST) {}
+
+ /**
+ * Mounts a group of routes in the router
+ *
+ * @param mixed $group
+ * @return RouterInterface
+ */
+ public function mount(\Phalcon\Mvc\Router\GroupInterface $group) {}
+
+ /**
+ * Set a group of paths to be returned when none of the defined routes are matched
+ *
+ * @param mixed $paths
+ * @return RouterInterface
+ */
+ public function notFound($paths) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Returns the processed namespace name
+ *
+ * @return string
+ */
+ public function getNamespaceName() {}
+
+ /**
+ * Returns the processed module name
+ *
+ * @return string
+ */
+ public function getModuleName() {}
+
+ /**
+ * Returns the processed controller name
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Returns the processed action name
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Returns the processed parameters
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Returns the route that matchs the handled URI
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getMatchedRoute() {}
+
+ /**
+ * Returns the sub expressions in the regular expression matched
+ *
+ * @return array
+ */
+ public function getMatches() {}
+
+ /**
+ * Checks if the router macthes any of the defined routes
+ *
+ * @return bool
+ */
+ public function wasMatched() {}
+
+ /**
+ * Returns all the routes defined in the router
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Returns a route object by its id
+ *
+ * @param mixed $id
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteById($id) {}
+
+ /**
+ * Returns a route object by its name
+ *
+ * @param string $name
+ * @return bool|\Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRouteByName($name) {}
+
+ /**
+ * Returns whether controller name should not be mangled
+ *
+ * @return bool
+ */
+ public function isExactControllerName() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/RouterInterface.php b/ide/2.0.6/Phalcon/mvc/RouterInterface.php
new file mode 100644
index 000000000..d649f3afb
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/RouterInterface.php
@@ -0,0 +1,212 @@
+
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2012'));
+ *
+ */
+class Url implements \Phalcon\Mvc\UrlInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_baseUri = null;
+
+
+ protected $_staticBaseUri = null;
+
+
+ protected $_basePath = null;
+
+
+ protected $_router;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a prefix for all the URIs to be generated
+ *
+ * $url->setBaseUri('/invo/');
+ * $url->setBaseUri('/invo/index.php/');
+ *
+ *
+ * @param string $baseUri
+ * @return Url
+ */
+ public function setBaseUri($baseUri) {}
+
+ /**
+ * Sets a prefix for all static URLs generated
+ *
+ * $url->setStaticBaseUri('/invo/');
+ *
+ *
+ * @param string $staticBaseUri
+ * @return Url
+ */
+ public function setStaticBaseUri($staticBaseUri) {}
+
+ /**
+ * Returns the prefix for all the generated urls. By default /
+ *
+ * @return string
+ */
+ public function getBaseUri() {}
+
+ /**
+ * Returns the prefix for all the generated static urls. By default /
+ *
+ * @return string
+ */
+ public function getStaticBaseUri() {}
+
+ /**
+ * Sets a base path for all the generated paths
+ *
+ * $url->setBasePath('/var/www/htdocs/');
+ *
+ *
+ * @param string $basePath
+ * @return Url
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Returns the base path
+ *
+ * @return string
+ */
+ public function getBasePath() {}
+
+ /**
+ * Generates a URL
+ *
+ * //Generate a URL appending the URI to the base URI
+ * echo $url->get('products/edit/1');
+ * //Generate a URL for a predefined route
+ * echo $url->get(array('for' => 'blog-post', 'title' => 'some-cool-stuff', 'year' => '2015'));
+ *
+ *
+ * @param mixed $uri
+ * @param mixed $args
+ * @param mixed $local
+ * @param mixed $baseUri
+ * @return string
+ */
+ public function get($uri = null, $args = null, $local = null, $baseUri = null) {}
+
+ /**
+ * Generates a URL for a static resource
+ *
+ * // Generate a URL for a static resource
+ * echo $url->getStatic("img/logo.png");
+ * // Generate a URL for a static predefined route
+ * echo $url->getStatic(array('for' => 'logo-cdn'));
+ *
+ *
+ * @param mixed $uri
+ * @return string
+ */
+ public function getStatic($uri = null) {}
+
+ /**
+ * Generates a local path
+ *
+ * @param string $path
+ * @return string
+ */
+ public function path($path = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/UrlInterface.php b/ide/2.0.6/Phalcon/mvc/UrlInterface.php
new file mode 100644
index 000000000..9d35e888c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/UrlInterface.php
@@ -0,0 +1,59 @@
+
+ * //Setting views directory
+ * $view = new \Phalcon\Mvc\View();
+ * $view->setViewsDir('app/views/');
+ * $view->start();
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->render('posts', 'recent');
+ * $view->finish();
+ * //Printing views output
+ * echo $view->getContent();
+ *
+ */
+class View extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewInterface
+{
+ /**
+ * Render Level: To the main layout
+ */
+ const LEVEL_MAIN_LAYOUT = 5;
+
+ /**
+ * Render Level: Render to the templates "after"
+ */
+ const LEVEL_AFTER_TEMPLATE = 4;
+
+ /**
+ * Render Level: To the controller layout
+ */
+ const LEVEL_LAYOUT = 3;
+
+ /**
+ * Render Level: To the templates "before"
+ */
+ const LEVEL_BEFORE_TEMPLATE = 2;
+
+ /**
+ * Render Level: To the action view
+ */
+ const LEVEL_ACTION_VIEW = 1;
+
+ /**
+ * Render Level: No render any view
+ */
+ const LEVEL_NO_RENDER = 0;
+
+ /**
+ * Cache Mode
+ */
+ const CACHE_MODE_NONE = 0;
+
+
+ const CACHE_MODE_INVERSE = 1;
+
+
+ protected $_options;
+
+
+ protected $_basePath = "";
+
+
+ protected $_content = "";
+
+
+ protected $_renderLevel = 5;
+
+
+ protected $_currentRenderLevel = 0;
+
+
+ protected $_disabledLevels;
+
+
+ protected $_viewParams;
+
+
+ protected $_layout;
+
+
+ protected $_layoutsDir = "";
+
+
+ protected $_partialsDir = "";
+
+
+ protected $_viewsDir;
+
+
+ protected $_templatesBefore;
+
+
+ protected $_templatesAfter;
+
+
+ protected $_engines = false;
+
+ /**
+ * @var array
+ */
+ protected $_registeredEngines;
+
+
+ protected $_mainView = "index";
+
+
+ protected $_controllerName;
+
+
+ protected $_actionName;
+
+
+ protected $_params;
+
+
+ protected $_pickView;
+
+
+ protected $_cache;
+
+
+ protected $_cacheLevel = 0;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_disabled = false;
+
+
+
+ public function getRenderLevel() {}
+
+
+ public function getCurrentRenderLevel() {}
+
+ /**
+ * @return array
+ */
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ * @return View
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Sets the layouts sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setLayoutsDir('../common/layouts/');
+ *
+ *
+ * @param string $layoutsDir
+ * @return View
+ */
+ public function setLayoutsDir($layoutsDir) {}
+
+ /**
+ * Gets the current layouts sub-directory
+ *
+ * @return string
+ */
+ public function getLayoutsDir() {}
+
+ /**
+ * Sets a partials sub-directory. Must be a directory under the views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setPartialsDir('../common/partials/');
+ *
+ *
+ * @param string $partialsDir
+ * @return View
+ */
+ public function setPartialsDir($partialsDir) {}
+
+ /**
+ * Gets the current partials sub-directory
+ *
+ * @return string
+ */
+ public function getPartialsDir() {}
+
+ /**
+ * Sets base path. Depending of your platform, always add a trailing slash or backslash
+ *
+ * $view->setBasePath(__DIR__ . '/');
+ *
+ *
+ * @param string $basePath
+ * @return View
+ */
+ public function setBasePath($basePath) {}
+
+ /**
+ * Gets base path
+ *
+ * @return string
+ */
+ public function getBasePath() {}
+
+ /**
+ * Sets the render level for the view
+ *
+ * //Render the view related to the controller only
+ * $this->view->setRenderLevel(View::LEVEL_LAYOUT);
+ *
+ *
+ * @param int $level
+ * @return View
+ */
+ public function setRenderLevel($level) {}
+
+ /**
+ * Disables a specific level of rendering
+ *
+ * //Render all levels except ACTION level
+ * $this->view->disableLevel(View::LEVEL_ACTION_VIEW);
+ *
+ *
+ * @param int|array $level
+ * @return \Phalcon\Mvc\View
+ */
+ public function disableLevel($level) {}
+
+ /**
+ * Sets default view name. Must be a file without extension in the views directory
+ *
+ * //Renders as main view views-dir/base.phtml
+ * $this->view->setMainView('base');
+ *
+ *
+ * @param string $viewPath
+ * @return View
+ */
+ public function setMainView($viewPath) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getMainView() {}
+
+ /**
+ * Change the layout to be used instead of using the name of the latest controller name
+ *
+ * $this->view->setLayout('main');
+ *
+ *
+ * @param string $layout
+ * @return View
+ */
+ public function setLayout($layout) {}
+
+ /**
+ * Returns the name of the main view
+ *
+ * @return string
+ */
+ public function getLayout() {}
+
+ /**
+ * Sets a template before the controller layout
+ *
+ * @param string|array $templateBefore
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateBefore($templateBefore) {}
+
+ /**
+ * Resets any "template before" layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateBefore() {}
+
+ /**
+ * Sets a "template after" controller layout
+ *
+ * @param string|array $templateAfter
+ * @return \Phalcon\Mvc\View
+ */
+ public function setTemplateAfter($templateAfter) {}
+
+ /**
+ * Resets any template before layouts
+ *
+ * @return View
+ */
+ public function cleanTemplateAfter() {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param boolean $merge
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return \Phalcon\Mvc\View
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Gets the name of the controller rendered
+ *
+ * @return string
+ */
+ public function getControllerName() {}
+
+ /**
+ * Gets the name of the action rendered
+ *
+ * @return string
+ */
+ public function getActionName() {}
+
+ /**
+ * Gets extra parameters of the action rendered
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Starts rendering process enabling the output buffering
+ *
+ * @return View
+ */
+ public function start() {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Checks whether view exists on registered extensions and render it
+ *
+ * @param array $engines
+ * @param string $viewPath
+ * @param boolean $silence
+ * @param boolean $mustClean
+ * @param mixed $cache
+ * @param \Phalcon\Cache\BackendInterface $$cache
+ */
+ protected function _engineRender($engines, $viewPath, $silence, $mustClean, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ * @return View
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Checks whether view exists
+ *
+ * @param string $view
+ * @return bool
+ */
+ public function exists($view) {}
+
+ /**
+ * Executes render process from dispatching data
+ *
+ * //Shows recent posts view (app/views/posts/recent.phtml)
+ * $view->start()->render('posts', 'recent')->finish();
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @return bool|View
+ */
+ public function render($controllerName, $actionName, $params = null) {}
+
+ /**
+ * Choose a different view to render instead of last-controller/last-action
+ *
+ * class ProductsController extends \Phalcon\Mvc\Controller
+ * {
+ * public function saveAction()
+ * {
+ * //Do some save stuff...
+ * //Then show the list view
+ * $this->view->pick("products/list");
+ * }
+ * }
+ *
+ *
+ * @param string|array $renderView
+ * @return \Phalcon\Mvc\View
+ */
+ public function pick($renderView) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Retrieve the contents of a partial
+ * echo $this->getPartial('shared/footer');
+ *
+ *
+ * //Retrieve the contents of a partial with arguments
+ * echo $this->getPartial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ * @return string
+ */
+ public function getPartial($partialPath, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Perform the automatic rendering returning the output as a string
+ *
+ * $template = $this->view->getRender('products', 'show', array('products' => $products));
+ *
+ *
+ * @param string $controllerName
+ * @param string $actionName
+ * @param array $params
+ * @param mixed $configCallback
+ * @return string
+ */
+ public function getRender($controllerName, $actionName, $params = null, $configCallback = null) {}
+
+ /**
+ * Finishes the render process by stopping the output buffering
+ *
+ * @return View
+ */
+ public function finish() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Check if the component is currently caching the output content
+ *
+ * @return bool
+ */
+ public function isCaching() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param boolean|array $options
+ * @return \Phalcon\Mvc\View
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return View
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Disables the auto-rendering process
+ *
+ * @return View
+ */
+ public function disable() {}
+
+ /**
+ * Enables the auto-rendering process
+ *
+ * @return View
+ */
+ public function enable() {}
+
+ /**
+ * Resets the view component to its factory default values
+ *
+ * @return View
+ */
+ public function reset() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+ /**
+ * Whether automatic rendering is enabled
+ *
+ * @return bool
+ */
+ public function isDisabled() {}
+
+ /**
+ * Magic method to retrieve if a variable is set in the view
+ *
+ * echo isset($this->view->products);
+ *
+ *
+ * @param string $key
+ * @return boolean
+ */
+ public function __isset($key) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/ViewBaseInterface.php b/ide/2.0.6/Phalcon/mvc/ViewBaseInterface.php
new file mode 100644
index 000000000..237308125
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/ViewBaseInterface.php
@@ -0,0 +1,86 @@
+x or array[x].
+ */
+class Document implements \Phalcon\Mvc\EntityInterface, \ArrayAccess
+{
+
+ /**
+ * Checks whether an offset exists in the document
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Returns the value of a field using the ArrayAccess interfase
+ *
+ * @param string $index
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Change a value using the ArrayAccess interface
+ *
+ * @param string $index
+ * @param mixed $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/collection/Exception.php b/ide/2.0.6/Phalcon/mvc/collection/Exception.php
new file mode 100644
index 000000000..736016ca9
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/collection/Exception.php
@@ -0,0 +1,12 @@
+
+ * $di = new \Phalcon\Di();
+ * $di->set('collectionManager', function(){
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized;
+
+
+ protected $_lastInitialized;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_connectionServices;
+
+
+ protected $_implicitObjectsIds;
+
+
+ protected $_behaviors;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the event manager
+ *
+ * @param mixed $eventsManager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService) {}
+
+ /**
+ * Sets whether a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds) {}
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param mixed $model
+ * @param \Phalcon\Mvc\CollectionInterface $$model
+ * @return \Mongo
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ * @return bool
+ */
+ public function missingMethod(\Phalcon\Mvc\CollectionInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/collection/ManagerInterface.php b/ide/2.0.6/Phalcon/mvc/collection/ManagerInterface.php
new file mode 100644
index 000000000..b51756b49
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/collection/ManagerInterface.php
@@ -0,0 +1,108 @@
+
+ * $di = new \Phalcon\Di();
+ * $di->set('collectionManager', function() {
+ * return new \Phalcon\Mvc\Collection\Manager();
+ * });
+ * $robot = new Robots(di);
+ *
+ */
+interface ManagerInterface
+{
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Events\ManagerInterface $eventsManager);
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Initializes a model in the models manager
+ *
+ * @param mixed $model
+ */
+ public function initialize(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName);
+
+ /**
+ * Get the latest initialized model
+ *
+ * @return \Phalcon\Mvc\CollectionInterface
+ */
+ public function getLastInitialized();
+
+ /**
+ * Sets a connection service for a specific model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\CollectionInterface $model, $connectionService);
+
+ /**
+ * Sets if a model must use implicit objects ids
+ *
+ * @param mixed $model
+ * @param bool $useImplicitObjectIds
+ */
+ public function useImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model, $useImplicitObjectIds);
+
+ /**
+ * Checks if a model is using implicit object ids
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingImplicitObjectIds(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Returns the connection related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection(\Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\CollectionInterface $model);
+
+ /**
+ * Binds a behavior to a collection
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\CollectionInterface $model, \Phalcon\Mvc\Collection\BehaviorInterface $behavior);
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/collection/behavior/SoftDelete.php b/ide/2.0.6/Phalcon/mvc/collection/behavior/SoftDelete.php
new file mode 100644
index 000000000..527ee606b
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/collection/behavior/SoftDelete.php
@@ -0,0 +1,21 @@
+
+ * $app = new \Phalcon\Mvc\Micro();
+ * $collection = new Collection();
+ * $collection->setHandler(new PostsController());
+ * $collection->get('/posts/edit/{id}', 'edit');
+ * $app->mount($collection);
+ *
+ */
+class Collection implements \Phalcon\Mvc\Micro\CollectionInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_lazy;
+
+
+ protected $_handler;
+
+
+ protected $_handlers;
+
+
+ /**
+ * Internal function to add a handler to the group
+ *
+ * @param string|array $method
+ * @param string $routePattern
+ * @param mixed $handler
+ * @param string $name
+ */
+ protected function _addMap($method, $routePattern, $handler, $name) {}
+
+ /**
+ * Sets a prefix for all routes added to the collection
+ *
+ * @param string $prefix
+ * @return Collection
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the collection prefix if any
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Returns the registered handlers
+ *
+ * @return array
+ */
+ public function getHandlers() {}
+
+ /**
+ * Sets the main handler
+ *
+ * @param mixed $handler
+ * @param boolean $lazy
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function setHandler($handler, $lazy = false) {}
+
+ /**
+ * Sets if the main handler must be lazy loaded
+ *
+ * @param bool $lazy
+ * @return Collection
+ */
+ public function setLazy($lazy) {}
+
+ /**
+ * Returns if the main handler must be lazy loaded
+ *
+ * @return bool
+ */
+ public function isLazy() {}
+
+ /**
+ * Returns the main handler
+ *
+ * @return mixed
+ */
+ public function getHandler() {}
+
+ /**
+ * Maps a route to a handler
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function map($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is GET
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function get($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is POST
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function post($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PUT
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function put($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is PATCH
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function patch($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is HEAD
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function head($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is DELETE
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param string $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function delete($routePattern, $handler, $name = null) {}
+
+ /**
+ * Maps a route to a handler that only matches if the HTTP method is OPTIONS
+ *
+ * @param string $routePattern
+ * @param callable $handler
+ * @param mixed $name
+ * @return \Phalcon\Mvc\Micro\Collection
+ */
+ public function options($routePattern, $handler, $name = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/micro/CollectionInterface.php b/ide/2.0.6/Phalcon/mvc/micro/CollectionInterface.php
new file mode 100644
index 000000000..30c219445
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/micro/CollectionInterface.php
@@ -0,0 +1,145 @@
+
+ * $robots = Robots::query()
+ * ->where("type = :type:")
+ * ->andWhere("year < 2000")
+ * ->bind(array("type" => "mechanical"))
+ * ->limit(5, 10)
+ * ->orderBy("name")
+ * ->execute();
+ *
+ */
+class Criteria implements \Phalcon\Mvc\Model\CriteriaInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_model;
+
+
+ protected $_params;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return null|\Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set a model on which the query will be executed
+ *
+ * @param string $modelName
+ * @return Criteria
+ */
+ public function setModelName($modelName) {}
+
+ /**
+ * Returns an internal model name on which the criteria will be applied
+ *
+ * @return string
+ */
+ public function getModelName() {}
+
+ /**
+ * Sets the bound parameters in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindParams
+ * @return Criteria
+ */
+ public function bind($bindParams) {}
+
+ /**
+ * Sets the bind types in the criteria
+ * This method replaces all previously set bound parameters
+ *
+ * @param array $bindTypes
+ * @return Criteria
+ */
+ public function bindTypes($bindTypes) {}
+
+ /**
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param mixed $distinct
+ * @return Criteria
+ */
+ public function distinct($distinct) {}
+
+ /**
+ * Sets the columns to be queried
+ *
+ * $criteria->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Criteria
+ */
+ public function columns($columns) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->join('Robots');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'LEFT');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @param mixed $type
+ * @return Criteria
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $criteria->innerJoin('Robots');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $criteria->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $criteria->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $criteria->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param mixed $conditions
+ * @param mixed $alias
+ * @return Criteria
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the conditions parameter in the criteria
+ *
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator (deprecated)
+ *
+ * @deprecated 1.0.0
+ * @see \Phalcon\Mvc\Model\Criteria::andWhere()
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function addWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an AND operator
+ *
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using an OR operator
+ *
+ * @param string $conditions
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @return Criteria
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Criteria
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Criteria
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Criteria
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Adds the conditions parameter to the criteria
+ *
+ * @param string $conditions
+ * @return Criteria
+ */
+ public function conditions($conditions) {}
+
+ /**
+ * Adds the order-by parameter to the criteria (deprecated)
+ *
+ * @deprecated 1.2.1
+ * @see \Phalcon\Mvc\Model\Criteria::orderBy()
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function order($orderColumns) {}
+
+ /**
+ * Adds the order-by clause to the criteria
+ *
+ * @param string $orderColumns
+ * @return Criteria
+ */
+ public function orderBy($orderColumns) {}
+
+ /**
+ * Adds the group-by clause to the criteria
+ *
+ * @param mixed $group
+ * @return Criteria
+ */
+ public function groupBy($group) {}
+
+ /**
+ * Adds the having clause to the criteria
+ *
+ * @param mixed $having
+ * @return Criteria
+ */
+ public function having($having) {}
+
+ /**
+ * Adds the limit parameter to the criteria
+ *
+ * @param mixed $limit
+ * @param mixed $offset
+ * @return Criteria
+ */
+ public function limit($limit, $offset = null) {}
+
+ /**
+ * Adds the "for_update" parameter to the criteria
+ *
+ * @param bool $forUpdate
+ * @return Criteria
+ */
+ public function forUpdate($forUpdate = true) {}
+
+ /**
+ * Adds the "shared_lock" parameter to the criteria
+ *
+ * @param bool $sharedLock
+ * @return Criteria
+ */
+ public function sharedLock($sharedLock = true) {}
+
+ /**
+ * Sets the cache options in the criteria
+ * This method replaces all previously set cache options
+ *
+ * @param array $cache
+ * @return Criteria
+ */
+ public function cache($cache) {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere() {}
+
+ /**
+ * Returns the columns to be queried
+ *
+ * @return string|array|null
+ */
+ public function getColumns() {}
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions() {}
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit() {}
+
+ /**
+ * Returns the order clause in the criteria
+ *
+ * @return string|null
+ */
+ public function getOrder() {}
+
+ /**
+ * Returns the group clause in the criteria
+ */
+ public function getGroupBy() {}
+
+ /**
+ * Returns the having clause in the criteria
+ */
+ public function getHaving() {}
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams() {}
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return Criteria
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data) {}
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function execute() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/CriteriaInterface.php b/ide/2.0.6/Phalcon/mvc/model/CriteriaInterface.php
new file mode 100644
index 000000000..495a337b3
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/CriteriaInterface.php
@@ -0,0 +1,219 @@
+
+ * $criteria->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function betweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $criteria->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return \Phalcon\Mvc\Model\CriteriaInterface
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum);
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $criteria->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function inWhere($expr, $values);
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $criteria->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return CriteriaInterface
+ */
+ public function notInWhere($expr, $values);
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getWhere();
+
+ /**
+ * Returns the conditions parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getConditions();
+
+ /**
+ * Returns the limit parameter in the criteria, which will be
+ * an integer if limit was set without an offset,
+ * an array with 'number' and 'offset' keys if an offset was set with the limit,
+ * or null if limit has not been set.
+ *
+ * @return int|array|null
+ */
+ public function getLimit();
+
+ /**
+ * Returns the order parameter in the criteria
+ *
+ * @return string|null
+ */
+ public function getOrder();
+
+ /**
+ * Returns all the parameters defined in the criteria
+ *
+ * @return array
+ */
+ public function getParams();
+
+ /**
+ * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST
+ *
+ * @param mixed $dependencyInjector
+ * @param string $modelName
+ * @param array $data
+ * @return CriteriaInterface
+ */
+ public static function fromInput(\Phalcon\DiInterface $dependencyInjector, $modelName, $data);
+
+ /**
+ * Executes a find using the parameters built with the criteria
+ *
+ * @return ResultsetInterface
+ */
+ public function execute();
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/Exception.php b/ide/2.0.6/Phalcon/mvc/model/Exception.php
new file mode 100644
index 000000000..1685da6d4
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/Exception.php
@@ -0,0 +1,12 @@
+
+ * use Phalcon\DI;
+ * use Phalcon\Mvc\Model\Manager as ModelsManager;
+ * $di = new DI();
+ * $di->set('modelsManager', function() {
+ * return new ModelsManager();
+ * });
+ * $robot = new Robots($di);
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\ManagerInterface, \Phalcon\Di\InjectionAwareInterface, \Phalcon\Events\EventsAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_eventsManager;
+
+
+ protected $_customEventsManager;
+
+
+ protected $_readConnectionServices;
+
+
+ protected $_writeConnectionServices;
+
+
+ protected $_aliases;
+
+ /**
+ * Has many relations
+ */
+ protected $_hasMany;
+
+ /**
+ * Has many relations by model
+ */
+ protected $_hasManySingle;
+
+ /**
+ * Has one relations
+ */
+ protected $_hasOne;
+
+ /**
+ * Has one relations by model
+ */
+ protected $_hasOneSingle;
+
+ /**
+ * Belongs to relations
+ */
+ protected $_belongsTo;
+
+ /**
+ * All the relationships by model
+ */
+ protected $_belongsToSingle;
+
+ /**
+ * Has many-Through relations
+ */
+ protected $_hasManyToMany;
+
+ /**
+ * Has many-Through relations by model
+ */
+ protected $_hasManyToManySingle;
+
+ /**
+ * Mark initialized models
+ */
+ protected $_initialized;
+
+
+ protected $_sources;
+
+
+ protected $_schemas;
+
+ /**
+ * Models' behaviors
+ */
+ protected $_behaviors;
+
+ /**
+ * Last model initialized
+ */
+ protected $_lastInitialized;
+
+ /**
+ * Last query created/executed
+ */
+ protected $_lastQuery;
+
+ /**
+ * Stores a list of reusable instances
+ */
+ protected $_reusable;
+
+
+ protected $_keepSnapshots;
+
+ /**
+ * Does the model use dynamic update, instead of updating all rows?
+ */
+ protected $_dynamicUpdate;
+
+
+ protected $_namespaceAliases;
+
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets a global events manager
+ *
+ * @param mixed $eventsManager
+ * @return Manager
+ */
+ public function setEventsManager(\Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns the internal event manager
+ *
+ * @return \Phalcon\Events\ManagerInterface
+ */
+ public function getEventsManager() {}
+
+ /**
+ * Sets a custom events manager for a specific model
+ *
+ * @param mixed $model
+ * @param mixed $eventsManager
+ */
+ public function setCustomEventsManager(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Events\ManagerInterface $eventsManager) {}
+
+ /**
+ * Returns a custom events manager related to a model
+ *
+ * @param mixed $model
+ * @return bool|\Phalcon\Events\ManagerInterface
+ */
+ public function getCustomEventsManager(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Initializes a model in the model manager
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function initialize(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check whether a model is already initialized
+ *
+ * @param string $modelName
+ * @return bool
+ */
+ public function isInitialized($modelName) {}
+
+ /**
+ * Get last initialized model
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getLastInitialized() {}
+
+ /**
+ * Loads a model throwing an exception if it doesn't exist
+ *
+ * @param string $modelName
+ * @param bool $newInstance
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function load($modelName, $newInstance = false) {}
+
+ /**
+ * Sets the mapped source for a model
+ *
+ * @param mixed $model
+ * @param string $source
+ */
+ public function setModelSource(\Phalcon\Mvc\ModelInterface $model, $source) {}
+
+ /**
+ * Returns the mapped source for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSource(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets the mapped schema for a model
+ *
+ * @param mixed $model
+ * @param string $schema
+ */
+ public function setModelSchema(\Phalcon\Mvc\ModelInterface $model, $schema) {}
+
+ /**
+ * Returns the mapped schema for a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getModelSchema(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets both write and read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets write connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setWriteConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Sets read connection service for a model
+ *
+ * @param mixed $model
+ * @param string $connectionService
+ */
+ public function setReadConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionService) {}
+
+ /**
+ * Returns the connection to read data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getReadConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to write data related to a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getWriteConnection(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection to read or write data related to a model depending on the connection services.
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ protected function _getConnection(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Returns the connection service name used to read data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getReadConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to write data related to a model
+ *
+ * @param mixed $model
+ * @return string
+ */
+ public function getWriteConnectionService(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the connection service name used to read or write data related to a model depending on the connection services
+ *
+ * @param mixed $model
+ * @param mixed $connectionServices
+ * @return string
+ */
+ public function _getConnectionService(\Phalcon\Mvc\ModelInterface $model, $connectionServices) {}
+
+ /**
+ * Receives events generated in the models and dispatches them to a events-manager if available
+ * Notify the behaviors that are listening in the model
+ *
+ * @param string $eventName
+ * @param mixed $model
+ */
+ public function notifyEvent($eventName, \Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Dispatch a event to the listeners and behaviors
+ * This method expects that the endpoint listeners/behaviors returns true
+ * meaning that a least one was implemented
+ *
+ * @param mixed $model
+ * @param string $eventName
+ * @param mixed $data
+ */
+ public function missingMethod(\Phalcon\Mvc\ModelInterface $model, $eventName, $data) {}
+
+ /**
+ * Binds a behavior to a model
+ *
+ * @param mixed $model
+ * @param mixed $behavior
+ */
+ public function addBehavior(\Phalcon\Mvc\ModelInterface $model, \Phalcon\Mvc\Model\BehaviorInterface $behavior) {}
+
+ /**
+ * Sets if a model must keep snapshots
+ *
+ * @param mixed $model
+ * @param bool $keepSnapshots
+ */
+ public function keepSnapshots(\Phalcon\Mvc\ModelInterface $model, $keepSnapshots) {}
+
+ /**
+ * Checks if a model is keeping snapshots for the queried records
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isKeepingSnapshots(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Sets if a model must use dynamic update instead of the all-field update
+ *
+ * @param mixed $model
+ * @param bool $dynamicUpdate
+ */
+ public function useDynamicUpdate(\Phalcon\Mvc\ModelInterface $model, $dynamicUpdate) {}
+
+ /**
+ * Checks if a model is using dynamic update instead of all-field update
+ *
+ * @param mixed $model
+ * @return bool
+ */
+ public function isUsingDynamicUpdate(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Setup a 1-1 relation between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasOne(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation reverse many to one between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param \Phalcon\Mvc\Model $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addBelongsTo(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setup a relation 1-n between two models
+ *
+ * @param mixed fields
+ * @param string referencedModel
+ * @param mixed referencedFields
+ * @param array options
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param mixed $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasMany(\Phalcon\Mvc\ModelInterface $model, $fields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Setups a relation n-m between two models
+ *
+ * @param string fields
+ * @param string intermediateModel
+ * @param string intermediateFields
+ * @param string intermediateReferencedFields
+ * @param string referencedModel
+ * @param string referencedFields
+ * @param mixed $model
+ * @param mixed $fields
+ * @param string $intermediateModel
+ * @param mixed $intermediateFields
+ * @param mixed $intermediateReferencedFields
+ * @param string $referencedModel
+ * @param mixed $referencedFields
+ * @param array $options
+ * @param $Phalcon\Mvc\ModelInterface model
+ * @return \Phalcon\Mvc\Model\Relation
+ */
+ public function addHasManyToMany(\Phalcon\Mvc\ModelInterface $model, $fields, $intermediateModel, $intermediateFields, $intermediateReferencedFields, $referencedModel, $referencedFields, $options = null) {}
+
+ /**
+ * Checks whether a model has a belongsTo relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsBelongsTo($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasMany($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasOne relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasOne($modelName, $modelRelation) {}
+
+ /**
+ * Checks whether a model has a hasManyToMany relation with another model
+ *
+ * @param string $modelName
+ * @param string $modelRelation
+ * @return bool
+ */
+ public function existsHasManyToMany($modelName, $modelRelation) {}
+
+ /**
+ * Returns a relation by its alias
+ *
+ * @param string $modelName
+ * @param string $alias
+ * @return bool|\Phalcon\Mvc\Model\Relation
+ */
+ public function getRelationByAlias($modelName, $alias) {}
+
+ /**
+ * Merge two arrays of find parameters
+ *
+ * @param mixed $findParamsOne
+ * @param mixed $findParamsTwo
+ * @return array
+ */
+ protected final function _mergeFindParameters($findParamsOne, $findParamsTwo) {}
+
+ /**
+ * Helper method to query records based on a relation definition
+ *
+ * @param mixed $relation
+ * @param string $method
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return \Phalcon\Mvc\Model\Resultset\Simple|Phalcon\Mvc\Model\Resultset\Simple|false
+ */
+ public function getRelationRecords(\Phalcon\Mvc\Model\RelationInterface $relation, $method, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Returns a reusable object from the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ */
+ public function getReusableRecords($modelName, $key) {}
+
+ /**
+ * Stores a reusable record in the internal list
+ *
+ * @param string $modelName
+ * @param string $key
+ * @param mixed $records
+ */
+ public function setReusableRecords($modelName, $key, $records) {}
+
+ /**
+ * Clears the internal reusable list
+ */
+ public function clearReusableObjects() {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getBelongsToRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets hasMany related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ public function getHasManyRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets belongsTo related records from a model
+ *
+ * @param string $method
+ * @param string $modelName
+ * @param mixed $modelRelation
+ * @param mixed $record
+ * @param mixed $parameters
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getHasOneRecords($method, $modelName, $modelRelation, \Phalcon\Mvc\ModelInterface $record, $parameters = null) {}
+
+ /**
+ * Gets all the belongsTo relations defined in a model
+ *
+ * $relations = $modelsManager->getBelongsTo(new Robots());
+ *
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getBelongsTo(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getHasOne(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasManyToMany relations defined on a model
+ *
+ * @param mixed $model
+ * @return array|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasManyToMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Gets hasOne relations defined on a model
+ *
+ * @param mixed $model
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getHasOneAndHasMany(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Query all the relationships defined on a model
+ *
+ * @param string $modelName
+ * @return \Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelations($modelName) {}
+
+ /**
+ * Query the first relationship defined between two models
+ *
+ * @param string $first
+ * @param string $second
+ * @return bool|\Phalcon\Mvc\Model\RelationInterface
+ */
+ public function getRelationsBetween($first, $second) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query without execute it
+ *
+ * @param string $phql
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function createQuery($phql) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query and execute it
+ *
+ * @param string $phql
+ * @param mixed $placeholders
+ * @param mixed $types
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function executeQuery($phql, $placeholders = null, $types = null) {}
+
+ /**
+ * Creates a Phalcon\Mvc\Model\Query\Builder
+ *
+ * @param mixed $params
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function createBuilder($params = null) {}
+
+ /**
+ * Returns the last query created or executed in the models manager
+ *
+ * @return \Phalcon\Mvc\Model\QueryInterface
+ */
+ public function getLastQuery() {}
+
+ /**
+ * Registers shorter aliases for namespaces in PHQL statements
+ *
+ * @param string $alias
+ * @param string $namespaceName
+ */
+ public function registerNamespaceAlias($alias, $namespaceName) {}
+
+ /**
+ * Returns a real namespace from its alias
+ *
+ * @param string $alias
+ * @return string
+ */
+ public function getNamespaceAlias($alias) {}
+
+ /**
+ * Returns all the registered namespace aliases
+ *
+ * @return array
+ */
+ public function getNamespaceAliases() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/ManagerInterface.php b/ide/2.0.6/Phalcon/mvc/model/ManagerInterface.php
new file mode 100644
index 000000000..2c5726c98
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/ManagerInterface.php
@@ -0,0 +1,366 @@
+
+ * use Phalcon\Mvc\Model\Message as Message;
+ * class Robots extends \Phalcon\Mvc\Model
+ * {
+ * public function beforeSave()
+ * {
+ * if (this->name == 'Peter') {
+ * text = "A robot cannot be named Peter";
+ * field = "name";
+ * type = "InvalidValue";
+ * message = new Message(text, field, type);
+ * this->appendMessage(message);
+ * }
+ * }
+ * }
+ *
+ */
+class Message implements \Phalcon\Mvc\Model\MessageInterface
+{
+
+ protected $_type;
+
+
+ protected $_message;
+
+
+ protected $_field;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Message constructor
+ *
+ * @param string $message
+ * @param string|array $field
+ * @param string $type
+ * @param \Phalcon\Mvc\ModelInterface $model
+ */
+ public function __construct($message, $field = null, $type = null, $model = null) {}
+
+ /**
+ * Sets message type
+ *
+ * @param string $type
+ * @return Message
+ */
+ public function setType($type) {}
+
+ /**
+ * Returns message type
+ *
+ * @return string
+ */
+ public function getType() {}
+
+ /**
+ * Sets verbose message
+ *
+ * @param string $message
+ * @return Message
+ */
+ public function setMessage($message) {}
+
+ /**
+ * Returns verbose message
+ *
+ * @return string
+ */
+ public function getMessage() {}
+
+ /**
+ * Sets field name related to message
+ *
+ * @param mixed $field
+ * @return Message
+ */
+ public function setField($field) {}
+
+ /**
+ * Returns field name related to message
+ */
+ public function getField() {}
+
+ /**
+ * Set the model who generates the message
+ *
+ * @param mixed $model
+ * @return Message
+ */
+ public function setModel(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the model that produced the message
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Magic __toString method returns verbose message
+ *
+ * @return string
+ */
+ public function __toString() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable exporting
+ *
+ * @param array $message
+ * @return Message
+ */
+ public static function __set_state($message) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/MessageInterface.php b/ide/2.0.6/Phalcon/mvc/model/MessageInterface.php
new file mode 100644
index 000000000..e192339b2
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/MessageInterface.php
@@ -0,0 +1,78 @@
+Because Phalcon\Mvc\Model requires meta-data like field names, data types, primary keys, etc.
+ * this component collect them and store for further querying by Phalcon\Mvc\Model.
+ * Phalcon\Mvc\Model\MetaData can also use adapters to store temporarily or permanently the meta-data.
+ * A standard Phalcon\Mvc\Model\MetaData can be used to query model attributes:
+ *
+ * $metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
+ * $attributes = $metaData->getAttributes(new Robots());
+ * print_r($attributes);
+ *
+ */
+abstract class MetaData implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ const MODELS_ATTRIBUTES = 0;
+
+
+ const MODELS_PRIMARY_KEY = 1;
+
+
+ const MODELS_NON_PRIMARY_KEY = 2;
+
+
+ const MODELS_NOT_NULL = 3;
+
+
+ const MODELS_DATA_TYPES = 4;
+
+
+ const MODELS_DATA_TYPES_NUMERIC = 5;
+
+
+ const MODELS_DATE_AT = 6;
+
+
+ const MODELS_DATE_IN = 7;
+
+
+ const MODELS_IDENTITY_COLUMN = 8;
+
+
+ const MODELS_DATA_TYPES_BIND = 9;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_INSERT = 10;
+
+
+ const MODELS_AUTOMATIC_DEFAULT_UPDATE = 11;
+
+
+ const MODELS_DEFAULT_VALUES = 12;
+
+
+ const MODELS_EMPTY_STRING_VALUES = 13;
+
+
+ const MODELS_COLUMN_MAP = 0;
+
+
+ const MODELS_REVERSE_COLUMN_MAP = 1;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_strategy;
+
+
+ protected $_metaData;
+
+
+ protected $_columnMap;
+
+
+ /**
+ * Initialize the metadata for certain table
+ *
+ * @param mixed $model
+ * @param mixed $key
+ * @param mixed $table
+ * @param mixed $schema
+ */
+ protected final function _initialize(\Phalcon\Mvc\ModelInterface $model, $key, $table, $schema) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Set the meta-data extraction strategy
+ *
+ * @param mixed $strategy
+ */
+ public function setStrategy(\Phalcon\Mvc\Model\MetaData\StrategyInterface $strategy) {}
+
+ /**
+ * Return the strategy to obtain the meta-data
+ *
+ * @return \Phalcon\Mvc\Model\MetaData\StrategyInterface
+ */
+ public function getStrategy() {}
+
+ /**
+ * Reads the complete meta-data for certain model
+ *
+ * print_r($metaData->readMetaData(new Robots());
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readMetaData(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads meta-data for certain model
+ *
+ * print_r($metaData->readMetaDataIndex(new Robots(), 0);
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Writes meta-data for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ * @param mixed $data
+ */
+ public final function writeMetaDataIndex(\Phalcon\Mvc\ModelInterface $model, $index, $data) {}
+
+ /**
+ * Reads the ordered/reversed column map for certain model
+ *
+ * print_r($metaData->readColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ */
+ public final function readColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Reads column-map information for certain model using a MODEL_* constant
+ *
+ * print_r($metaData->readColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP));
+ *
+ *
+ * @param mixed $model
+ * @param int $index
+ */
+ public final function readColumnMapIndex(\Phalcon\Mvc\ModelInterface $model, $index) {}
+
+ /**
+ * Returns table attributes names (fields)
+ *
+ * print_r($metaData->getAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are part of the primary key
+ *
+ * print_r($metaData->getPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of fields which are not part of the primary key
+ *
+ * print_r($metaData->getNonPrimaryKeyAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNonPrimaryKeyAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns an array of not null attributes
+ *
+ * print_r($metaData->getNotNullAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getNotNullAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their data types
+ *
+ * print_r($metaData->getDataTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes which types are numerical
+ *
+ * print_r($metaData->getDataTypesNumeric(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDataTypesNumeric(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the name of identity field (if one is present)
+ *
+ * print_r($metaData->getIdentityField(new Robots()));
+ *
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @return string
+ */
+ public function getIdentityField(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes and their bind data types
+ *
+ * print_r($metaData->getBindTypes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getBindTypes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the INSERT SQL generation
+ *
+ * print_r($metaData->getAutomaticCreateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes that must be ignored from the UPDATE SQL generation
+ *
+ * print_r($metaData->getAutomaticUpdateAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Set the attributes that must be ignored from the INSERT SQL generation
+ *
+ * $metaData->setAutomaticCreateAttributes(new Robots(), array('created_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticCreateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that must be ignored from the UPDATE SQL generation
+ *
+ * $metaData->setAutomaticUpdateAttributes(new Robots(), array('modified_at' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setAutomaticUpdateAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Set the attributes that allow empty string values
+ *
+ * $metaData->setEmptyStringAttributes(new Robots(), array('name' => true));
+ *
+ *
+ * @param mixed $model
+ * @param array $attributes
+ */
+ public function setEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model, $attributes) {}
+
+ /**
+ * Returns attributes allow empty strings
+ *
+ * print_r($metaData->getEmptyStringAttributes(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getEmptyStringAttributes(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns attributes (which have default values) and their default values
+ *
+ * print_r($metaData->getDefaultValues(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getDefaultValues(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the column map if any
+ *
+ * print_r($metaData->getColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Returns the reverse column map if any
+ *
+ * print_r($metaData->getReverseColumnMap(new Robots()));
+ *
+ *
+ * @param mixed $model
+ * @return array
+ */
+ public function getReverseColumnMap(\Phalcon\Mvc\ModelInterface $model) {}
+
+ /**
+ * Check if a model has certain attribute
+ *
+ * var_dump($metaData->hasAttribute(new Robots(), 'name'));
+ *
+ *
+ * @param mixed $model
+ * @param string $attribute
+ * @return bool
+ */
+ public function hasAttribute(\Phalcon\Mvc\ModelInterface $model, $attribute) {}
+
+ /**
+ * Checks if the internal meta-data container is empty
+ *
+ * var_dump($metaData->isEmpty());
+ *
+ *
+ * @return bool
+ */
+ public function isEmpty() {}
+
+ /**
+ * Resets internal meta-data in order to regenerate it
+ *
+ * $metaData->reset();
+ *
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/MetaDataInterface.php b/ide/2.0.6/Phalcon/mvc/model/MetaDataInterface.php
new file mode 100644
index 000000000..930c326a7
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/MetaDataInterface.php
@@ -0,0 +1,241 @@
+
+ * $phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
+ * WHERE b.name = :name: ORDER BY c.name";
+ * $result = manager->executeQuery($phql, array(
+ * "name": "Lamborghini"
+ * ));
+ * foreach ($result as $row) {
+ * echo "Name: ", $row->cars->name, "\n";
+ * echo "Price: ", $row->cars->price, "\n";
+ * echo "Taxes: ", $row->taxes, "\n";
+ * }
+ *
+ */
+class Query implements \Phalcon\Mvc\Model\QueryInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ const TYPE_SELECT = 309;
+
+
+ const TYPE_INSERT = 306;
+
+
+ const TYPE_UPDATE = 300;
+
+
+ const TYPE_DELETE = 303;
+
+
+ protected $_dependencyInjector;
+
+
+ protected $_manager;
+
+
+ protected $_metaData;
+
+
+ protected $_type;
+
+
+ protected $_phql;
+
+
+ protected $_ast;
+
+
+ protected $_intermediate;
+
+
+ protected $_models;
+
+
+ protected $_sqlAliases;
+
+
+ protected $_sqlAliasesModels;
+
+
+ protected $_sqlModelsAliases;
+
+
+ protected $_sqlAliasesModelsInstances;
+
+
+ protected $_sqlColumnAliases;
+
+
+ protected $_modelsInstances;
+
+
+ protected $_cache;
+
+
+ protected $_cacheOptions;
+
+
+ protected $_uniqueRow;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ static protected $_irPhqlCache;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query constructor
+ *
+ * @param string $phql
+ * @param \Phalcon\DiInterface $dependencyInjector
+ */
+ public function __construct($phql = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Tells to the query if only the first row in the resultset must be returned
+ *
+ * @param bool $uniqueRow
+ * @return Query
+ */
+ public function setUniqueRow($uniqueRow) {}
+
+ /**
+ * Check if the query is programmed to get only the first row in the resultset
+ *
+ * @return bool
+ */
+ public function getUniqueRow() {}
+
+ /**
+ * Replaces the model's name to its source name in a qualifed-name expression
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getQualified($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $argument
+ * @return array
+ */
+ protected final function _getCallArgument($argument) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getCaseExpression($expr) {}
+
+ /**
+ * Resolves a expression in a single call argument
+ *
+ * @param array $expr
+ * @return array
+ */
+ protected final function _getFunctionCall($expr) {}
+
+ /**
+ * Resolves an expression from its intermediate code into a string
+ *
+ * @param array $expr
+ * @param boolean $quoting
+ * @return string
+ */
+ protected final function _getExpression($expr, $quoting = true) {}
+
+ /**
+ * Resolves a column from its intermediate representation into an array used to determine
+ * if the resultset produced is simple or complex
+ *
+ * @param array $column
+ * @return array
+ */
+ protected final function _getSelectColumn($column) {}
+
+ /**
+ * Resolves a table in a SELECT statement checking if the model exists
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $qualifiedName
+ * @return string
+ */
+ protected final function _getTable(\Phalcon\Mvc\Model\ManagerInterface $manager, $qualifiedName) {}
+
+ /**
+ * Resolves a JOIN clause checking if the associated models exist
+ *
+ * @param \Phalcon\Mvc\Model\ManagerInterface $manager
+ * @param array $join
+ * @return array
+ */
+ protected final function _getJoin(\Phalcon\Mvc\Model\ManagerInterface $manager, $join) {}
+
+ /**
+ * Resolves a JOIN type
+ *
+ * @param array $join
+ * @return string
+ */
+ protected final function _getJoinType($join) {}
+
+ /**
+ * Resolves joins involving has-one/belongs-to/has-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getSingleJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Resolves joins involving many-to-many relations
+ *
+ * @param string $joinType
+ * @param string $joinSource
+ * @param string $modelAlias
+ * @param string $joinAlias
+ * @param \Phalcon\Mvc\Model\RelationInterface $relation
+ * @return array
+ */
+ protected final function _getMultiJoin($joinType, $joinSource, $modelAlias, $joinAlias, \Phalcon\Mvc\Model\RelationInterface $relation) {}
+
+ /**
+ * Processes the JOINs in the query returning an internal representation for the database dialect
+ *
+ * @param array $select
+ * @return array
+ */
+ protected final function _getJoins($select) {}
+
+ /**
+ * Returns a processed order clause for a SELECT statement
+ *
+ * @param mixed $order
+ * @param array|string $$order
+ * @return array
+ */
+ protected final function _getOrderClause($order) {}
+
+ /**
+ * Returns a processed group clause for a SELECT statement
+ *
+ * @param array $group
+ * @return array
+ */
+ protected final function _getGroupClause($group) {}
+
+ /**
+ * Returns a processed limit clause for a SELECT statement
+ *
+ * @param array $limitClause
+ * @return array
+ */
+ protected final function _getLimitClause($limitClause) {}
+
+ /**
+ * Analyzes a SELECT intermediate code and produces an array to be executed later
+ *
+ * @param mixed $ast
+ * @param mixed $merge
+ * @return array
+ */
+ protected final function _prepareSelect($ast = null, $merge = null) {}
+
+ /**
+ * Analyzes an INSERT intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareInsert() {}
+
+ /**
+ * Analyzes an UPDATE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareUpdate() {}
+
+ /**
+ * Analyzes a DELETE intermediate code and produces an array to be executed later
+ *
+ * @return array
+ */
+ protected final function _prepareDelete() {}
+
+ /**
+ * Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang generating another
+ * intermediate representation that could be executed by Phalcon\Mvc\Model\Query
+ *
+ * @return array
+ */
+ public function parse() {}
+
+ /**
+ * Returns the current cache backend instance
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Executes the SELECT intermediate representation producing a Phalcon\Mvc\Model\Resultset
+ *
+ * @param mixed $intermediate
+ * @param mixed $bindParams
+ * @param mixed $bindTypes
+ * @param bool $simulate
+ * @return array|\Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _executeSelect($intermediate, $bindParams, $bindTypes, $simulate = false) {}
+
+ /**
+ * Executes the INSERT intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeInsert($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the UPDATE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeUpdate($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes the DELETE intermediate representation producing a Phalcon\Mvc\Model\Query\Status
+ *
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\StatusInterface
+ */
+ protected final function _executeDelete($intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Query the records on which the UPDATE/DELETE operation well be done
+ *
+ * @param \Phalcon\Mvc\ModelInterface $model
+ * @param array $intermediate
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\ResultsetInterface
+ */
+ protected final function _getRelatedRecords(\Phalcon\Mvc\ModelInterface $model, $intermediate, $bindParams, $bindTypes) {}
+
+ /**
+ * Executes a parsed PHQL statement
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return mixed
+ */
+ public function execute($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Executes the query returning the first result
+ *
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getSingleResult($bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Sets the type of PHQL statement to be executed
+ *
+ * @param int $type
+ * @return Query
+ */
+ public function setType($type) {}
+
+ /**
+ * Gets the type of PHQL statement executed
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindParams
+ * @param bool $merge
+ * @return Query
+ */
+ public function setBindParams($bindParams, $merge = false) {}
+
+ /**
+ * Returns default bind params
+ *
+ * @return array
+ */
+ public function getBindParams() {}
+
+ /**
+ * Set default bind parameters
+ *
+ * @param array $bindTypes
+ * @param bool $merge
+ * @return Query
+ */
+ public function setBindTypes($bindTypes, $merge = false) {}
+
+ /**
+ * Returns default bind types
+ *
+ * @return array
+ */
+ public function getBindTypes() {}
+
+ /**
+ * Allows to set the IR to be executed
+ *
+ * @param array $intermediate
+ * @return Query
+ */
+ public function setIntermediate($intermediate) {}
+
+ /**
+ * Returns the intermediate representation of the PHQL statement
+ *
+ * @return array
+ */
+ public function getIntermediate() {}
+
+ /**
+ * Sets the cache parameters of the query
+ *
+ * @param mixed $cacheOptions
+ * @return Query
+ */
+ public function cache($cacheOptions) {}
+
+ /**
+ * Returns the current cache options
+ *
+ * @param array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Returns the SQL to be generated by the internal PHQL (only works in SELECT statements)
+ *
+ * @return array
+ */
+ public function getSql() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/QueryInterface.php b/ide/2.0.6/Phalcon/mvc/model/QueryInterface.php
new file mode 100644
index 000000000..058d68f18
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/QueryInterface.php
@@ -0,0 +1,59 @@
+
+ * //Using a standard foreach
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * foreach ($robots as robot) {
+ * echo robot->name, "\n";
+ * }
+ * //Using a while
+ * $robots = Robots::find(array("type='virtual'", "order" => "name"));
+ * $robots->rewind();
+ * while ($robots->valid()) {
+ * $robot = $robots->current();
+ * echo $robot->name, "\n";
+ * $robots->next();
+ * }
+ *
+ */
+abstract class Resultset implements \Phalcon\Mvc\Model\ResultsetInterface, \Iterator, \SeekableIterator, \Countable, \ArrayAccess, \Serializable
+{
+
+ const TYPE_RESULT_FULL = 0;
+
+
+ const TYPE_RESULT_PARTIAL = 1;
+
+
+ const HYDRATE_RECORDS = 0;
+
+
+ const HYDRATE_OBJECTS = 2;
+
+
+ const HYDRATE_ARRAYS = 1;
+
+ /**
+ * Phalcon\Db\ResultInterface or false for empty resultset
+ */
+ protected $_result = false;
+
+
+ protected $_cache;
+
+
+ protected $_isFresh = true;
+
+
+ protected $_pointer = 0;
+
+
+ protected $_count;
+
+
+ protected $_activeRow = null;
+
+
+ protected $_rows = null;
+
+
+ protected $_row = null;
+
+
+ protected $_errorMessages;
+
+
+ protected $_hydrateMode = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Resultset constructor
+ *
+ * @param \Phalcon\Db\ResultInterface|false $result
+ * @param \Phalcon\Cache\BackendInterface $cache
+ * @param array $columnTypes
+ */
+ public function __construct($result, \Phalcon\Cache\BackendInterface $cache = null) {}
+
+ /**
+ * Moves cursor to next row in the resultset
+ */
+ public function next() {}
+
+ /**
+ * Check whether internal resource has rows to fetch
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Gets pointer number of active row in the resultset
+ *
+ * @return int|null
+ */
+ public function key() {}
+
+ /**
+ * Rewinds resultset to its beginning
+ */
+ public final function rewind() {}
+
+ /**
+ * Changes internal pointer to a specific position in the resultset
+ * Set new position if required and set this->_row
+ *
+ * @param int $position
+ */
+ public final function seek($position) {}
+
+ /**
+ * Counts how many rows are in the resultset
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Checks whether offset exists in the resultset
+ *
+ * @param int $index
+ * @return bool
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets row in a specific position of the resultset
+ *
+ * @param int $index
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Resultsets cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Returns the internal type of data retrieval that the resultset is using
+ *
+ * @return int
+ */
+ public function getType() {}
+
+ /**
+ * Get first row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getFirst() {}
+
+ /**
+ * Get last row in the resultset
+ *
+ * @return bool|\Phalcon\Mvc\ModelInterface
+ */
+ public function getLast() {}
+
+ /**
+ * Set if the resultset is fresh or an old one cached
+ *
+ * @param bool $isFresh
+ * @return Resultset
+ */
+ public function setIsFresh($isFresh) {}
+
+ /**
+ * Tell if the resultset if fresh or an old one cached
+ *
+ * @return bool
+ */
+ public function isFresh() {}
+
+ /**
+ * Sets the hydration mode in the resultset
+ *
+ * @param int $hydrateMode
+ * @return Resultset
+ */
+ public function setHydrateMode($hydrateMode) {}
+
+ /**
+ * Returns the current hydration mode
+ *
+ * @return int
+ */
+ public function getHydrateMode() {}
+
+ /**
+ * Returns the associated cache for the resultset
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Returns the error messages produced by a batch operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Updates every record in the resultset
+ *
+ * @param array $data
+ * @param \Closure $conditionCallback
+ * @return boolean
+ */
+ public function update($data, \Closure $conditionCallback = null) {}
+
+ /**
+ * Deletes every record in the resultset
+ *
+ * @param mixed $conditionCallback
+ * @return bool
+ */
+ public function delete(\Closure $conditionCallback = null) {}
+
+ /**
+ * Filters a resultset returning only those the developer requires
+ *
+ * $filtered = $robots->filter(function($robot){
+ * if ($robot->id < 3) {
+ * return $robot;
+ * }
+ * });
+ *
+ *
+ * @param callback $filter
+ * @return \Phalcon\Mvc\Model[]
+ */
+ public function filter($filter) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/ResultsetInterface.php b/ide/2.0.6/Phalcon/mvc/model/ResultsetInterface.php
new file mode 100644
index 000000000..58903e36e
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/ResultsetInterface.php
@@ -0,0 +1,62 @@
+x or array[x].
+ */
+class Row implements \Phalcon\Mvc\EntityInterface, \Phalcon\Mvc\Model\ResultInterface, \ArrayAccess
+{
+
+ /**
+ * Set the current object's state
+ *
+ * @param int $dirtyState
+ * @return bool
+ */
+ public function setDirtyState($dirtyState) {}
+
+ /**
+ * Checks whether offset exists in the row
+ *
+ * @param mixed $index
+ * @param string|int $$index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Gets a record in a specific position of the row
+ *
+ * @param string|int $index
+ * @return string|Phalcon\Mvc\ModelInterface
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $index
+ * @param \Phalcon\Mvc\ModelInterface $value
+ */
+ public function offsetSet($index, $value) {}
+
+ /**
+ * Rows cannot be changed. It has only been implemented to meet the definition of the ArrayAccess interface
+ *
+ * @param string|int $offset
+ */
+ public function offsetUnset($offset) {}
+
+ /**
+ * Reads an attribute value by its name
+ *
+ * echo $robot->readAttribute('name');
+ *
+ *
+ * @param string $attribute
+ * @return mixed
+ */
+ public function readAttribute($attribute) {}
+
+ /**
+ * Writes an attribute value by its name
+ *
+ * $robot->writeAttribute('name', 'Rosey');
+ *
+ *
+ * @param string $attribute
+ * @param mixed $value
+ */
+ public function writeAttribute($attribute, $value) {}
+
+ /**
+ * Returns the instance as an array representation
+ *
+ * @return array
+ */
+ public function toArray() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/Transaction.php b/ide/2.0.6/Phalcon/mvc/model/Transaction.php
new file mode 100644
index 000000000..cfc88900d
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/Transaction.php
@@ -0,0 +1,146 @@
+
+ * try {
+ * $manager = new \Phalcon\Mvc\Model\Transaction\Manager();
+ * $transaction = $manager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if ($robot->save() == false) {
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if ($robotPart->save() == false) {
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch(Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Transaction implements \Phalcon\Mvc\Model\TransactionInterface
+{
+
+ protected $_connection;
+
+
+ protected $_activeTransaction = false;
+
+
+ protected $_isNewTransaction = true;
+
+
+ protected $_rollbackOnAbort = false;
+
+
+ protected $_manager;
+
+
+ protected $_messages;
+
+
+ protected $_rollbackRecord;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction constructor
+ *
+ * @param mixed $dependencyInjector
+ * @param boolean $autoBegin
+ * @param string $service
+ * @param \Phalcon\DiInterface $$ependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector, $autoBegin = false, $service = null) {}
+
+ /**
+ * Sets transaction manager related to the transaction
+ *
+ * @param mixed $manager
+ */
+ public function setTransactionManager(\Phalcon\Mvc\Model\Transaction\ManagerInterface $manager) {}
+
+ /**
+ * Starts the transaction
+ *
+ * @return bool
+ */
+ public function begin() {}
+
+ /**
+ * Commits the transaction
+ *
+ * @return bool
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks the transaction
+ *
+ * @param string $rollbackMessage
+ * @param \Phalcon\Mvc\ModelInterface $rollbackRecord
+ * @return boolean
+ */
+ public function rollback($rollbackMessage = null, $rollbackRecord = null) {}
+
+ /**
+ * Returns the connection related to transaction
+ *
+ * @return \Phalcon\Db\AdapterInterface
+ */
+ public function getConnection() {}
+
+ /**
+ * Sets if is a reused transaction or new once
+ *
+ * @param bool $isNew
+ */
+ public function setIsNewTransaction($isNew) {}
+
+ /**
+ * Sets flag to rollback on abort the HTTP connection
+ *
+ * @param bool $rollbackOnAbort
+ */
+ public function setRollbackOnAbort($rollbackOnAbort) {}
+
+ /**
+ * Checks whether transaction is managed by a transaction manager
+ *
+ * @return bool
+ */
+ public function isManaged() {}
+
+ /**
+ * Returns validations messages from last save try
+ *
+ * @return array
+ */
+ public function getMessages() {}
+
+ /**
+ * Checks whether internal connection is under an active transaction
+ *
+ * @return bool
+ */
+ public function isValid() {}
+
+ /**
+ * Sets object which generates rollback action
+ *
+ * @param mixed $record
+ */
+ public function setRollbackedRecord(\Phalcon\Mvc\ModelInterface $record) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/TransactionInterface.php b/ide/2.0.6/Phalcon/mvc/model/TransactionInterface.php
new file mode 100644
index 000000000..88a500734
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/TransactionInterface.php
@@ -0,0 +1,91 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Apc(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Apc extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Apc constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from APC
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to APC
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/metadata/Files.php b/ide/2.0.6/Phalcon/mvc/model/metadata/Files.php
new file mode 100644
index 000000000..86b59be2c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/metadata/Files.php
@@ -0,0 +1,43 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Files(array(
+ * 'metaDataDir' => 'app/cache/metadata/'
+ * ));
+ *
+ */
+class Files extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_metaDataDir = "./";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Files constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from files
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to files
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/metadata/Libmemcached.php b/ide/2.0.6/Phalcon/mvc/model/metadata/Libmemcached.php
new file mode 100644
index 000000000..aa7c47fd2
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/metadata/Libmemcached.php
@@ -0,0 +1,60 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Libmemcached(array(
+ * 'servers' => array(
+ * array('host' => 'localhost', 'port' => 11211, 'weight' => 1),
+ * ),
+ * 'client' => array(
+ * Memcached::OPT_HASH => Memcached::HASH_MD5,
+ * Memcached::OPT_PREFIX_KEY => 'prefix.',
+ * ),
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ *
+ */
+class Libmemcached extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_ttl = 172800;
+
+
+ protected $_memcache = null;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Libmemcached constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from Memcache
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to Memcache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+ /**
+ * Flush Memcache data and resets internal meta-data in order to regenerate it
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/metadata/Memcache.php b/ide/2.0.6/Phalcon/mvc/model/metadata/Memcache.php
new file mode 100644
index 000000000..73637fade
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/metadata/Memcache.php
@@ -0,0 +1,56 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Memcache(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400,
+ * 'host' => 'localhost',
+ * 'port' => 11211,
+ * 'persistent' => false
+ * ));
+ *
+ */
+class Memcache extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_ttl = 172800;
+
+
+ protected $_memcache = null;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Memcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from Memcache
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to Memcache
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+ /**
+ * Flush Memcache data and resets internal meta-data in order to regenerate it
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/metadata/Memory.php b/ide/2.0.6/Phalcon/mvc/model/metadata/Memory.php
new file mode 100644
index 000000000..c389c473f
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/metadata/Memory.php
@@ -0,0 +1,35 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Redis(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400,
+ * 'host' => 'localhost',
+ * 'port' => 6379,
+ * 'persistent' => false
+ * ));
+ *
+ */
+class Redis extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_ttl = 172800;
+
+
+ protected $_redis = null;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Redis constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from Redis
+ *
+ * @param string $key
+ * @return array|null
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to Redis
+ *
+ * @param string $key
+ * @param mixed $data
+ */
+ public function write($key, $data) {}
+
+ /**
+ * Flush Redis data and resets internal meta-data in order to regenerate it
+ */
+ public function reset() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/metadata/Session.php b/ide/2.0.6/Phalcon/mvc/model/metadata/Session.php
new file mode 100644
index 000000000..fad34d788
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/metadata/Session.php
@@ -0,0 +1,45 @@
+
+ * $metaData = new \Phalcon\Mvc\Model\Metadata\Session(array(
+ * 'prefix' => 'my-app-id'
+ * ));
+ *
+ */
+class Session extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Session constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads meta-data from $_SESSION
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the meta-data to $_SESSION
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/metadata/StrategyInterface.php b/ide/2.0.6/Phalcon/mvc/model/metadata/StrategyInterface.php
new file mode 100644
index 000000000..b7874be24
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/metadata/StrategyInterface.php
@@ -0,0 +1,28 @@
+
+ * $metaData = new Phalcon\Mvc\Model\Metadata\Xcache(array(
+ * 'prefix' => 'my-app-id',
+ * 'lifetime' => 86400
+ * ));
+ *
+ */
+class Xcache extends \Phalcon\Mvc\Model\MetaData implements \Phalcon\Mvc\Model\MetaDataInterface
+{
+
+ protected $_prefix = "";
+
+
+ protected $_ttl = 172800;
+
+
+ /**
+ * Phalcon\Mvc\Model\MetaData\Xcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Reads metadata from XCache
+ *
+ * @param string $key
+ * @return array
+ */
+ public function read($key) {}
+
+ /**
+ * Writes the metadata to XCache
+ *
+ * @param string $key
+ * @param array $data
+ */
+ public function write($key, $data) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/metadata/strategy/Annotations.php b/ide/2.0.6/Phalcon/mvc/model/metadata/strategy/Annotations.php
new file mode 100644
index 000000000..f1b7b11fa
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/metadata/strategy/Annotations.php
@@ -0,0 +1,27 @@
+
+ * $params = array(
+ * 'models' => array('Users'),
+ * 'columns' => array('id', 'name', 'status'),
+ * 'conditions' => array(
+ * array(
+ * "created > :min: AND created < :max:",
+ * array("min" => '2013-01-01', 'max' => '2014-01-01'),
+ * array("min" => PDO::PARAM_STR, 'max' => PDO::PARAM_STR),
+ * ),
+ * ),
+ * // or 'conditions' => "created > '2013-01-01' AND created < '2014-01-01'",
+ * 'group' => array('id', 'name'),
+ * 'having' => "name = 'Kamil'",
+ * 'order' => array('name', 'id'),
+ * 'limit' => 20,
+ * 'offset' => 20,
+ * // or 'limit' => array(20, 20),
+ * );
+ * $queryBuilder = new \Phalcon\Mvc\Model\Query\Builder($params);
+ *
+ */
+class Builder implements \Phalcon\Mvc\Model\Query\BuilderInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_columns;
+
+
+ protected $_models;
+
+
+ protected $_joins;
+
+
+ protected $_with;
+
+
+ protected $_conditions;
+
+
+ protected $_group;
+
+
+ protected $_having;
+
+
+ protected $_order;
+
+
+ protected $_limit;
+
+
+ protected $_offset;
+
+
+ protected $_forUpdate;
+
+
+ protected $_sharedLock;
+
+
+ protected $_bindParams;
+
+
+ protected $_bindTypes;
+
+
+ protected $_distinct;
+
+
+ protected $_hiddenParamNumber = 0;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Builder constructor
+ *
+ * @param mixed $params
+ * @param mixed $dependencyInjector
+ */
+ public function __construct($params = null, \Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ * @return Builder
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets SELECT DISTINCT / SELECT ALL flag
+ *
+ * @param bool|null $distinct
+ * @return \Phalcon\Mvc\Model\Query\BuilderInterface
+ */
+ public function distinct($distinct) {}
+
+ /**
+ * Returns SELECT DISTINCT / SELECT ALL flag
+ *
+ * @return bool
+ */
+ public function getDistinct() {}
+
+ /**
+ * Sets the columns to be queried
+ *
+ * $builder->columns(array('id', 'name'));
+ *
+ *
+ * @param string|array $columns
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function columns($columns) {}
+
+ /**
+ * Return the columns to be queried
+ *
+ * @return string|array
+ */
+ public function getColumns() {}
+
+ /**
+ * Sets the models who makes part of the query
+ *
+ * $builder->from('Robots');
+ * $builder->from(array('Robots', 'RobotsParts'));
+ *
+ *
+ * @param string|array $models
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function from($models) {}
+
+ /**
+ * Add a model to take part of the query
+ *
+ * $builder->addFrom('Robots', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function addFrom($model, $alias = null) {}
+
+ /**
+ * Return the models who makes part of the query
+ *
+ * @return string|array
+ */
+ public function getFrom() {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->join('Robots');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ * $builder->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'INNER');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function join($model, $conditions = null, $alias = null, $type = null) {}
+
+ /**
+ * Adds a INNER join to the query
+ *
+ * $builder->innerJoin('Robots');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id');
+ * $builder->innerJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @param string $type
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function innerJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a LEFT join to the query
+ *
+ * $builder->leftJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function leftJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Adds a RIGHT join to the query
+ *
+ * $builder->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
+ *
+ *
+ * @param string $model
+ * @param string $conditions
+ * @param string $alias
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function rightJoin($model, $conditions = null, $alias = null) {}
+
+ /**
+ * Sets the query conditions
+ *
+ * $builder->where(100);
+ * $builder->where('name = "Peter"');
+ * $builder->where('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param mixed $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function where($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a AND operator
+ *
+ * $builder->andWhere('name = "Peter"');
+ * $builder->andWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function andWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a condition to the current conditions using a OR operator
+ *
+ * $builder->orWhere('name = "Peter"');
+ * $builder->orWhere('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
+ *
+ *
+ * @param string $conditions
+ * @param array $bindParams
+ * @param array $bindTypes
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orWhere($conditions, $bindParams = null, $bindTypes = null) {}
+
+ /**
+ * Appends a BETWEEN condition to the current conditions
+ *
+ * $builder->betweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Builder
+ */
+ public function betweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends a NOT BETWEEN condition to the current conditions
+ *
+ * $builder->notBetweenWhere('price', 100.25, 200.50);
+ *
+ *
+ * @param string $expr
+ * @param mixed $minimum
+ * @param mixed $maximum
+ * @return Builder
+ */
+ public function notBetweenWhere($expr, $minimum, $maximum) {}
+
+ /**
+ * Appends an IN condition to the current conditions
+ *
+ * $builder->inWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function inWhere($expr, $values) {}
+
+ /**
+ * Appends a NOT IN condition to the current conditions
+ *
+ * $builder->notInWhere('id', [1, 2, 3]);
+ *
+ *
+ * @param string $expr
+ * @param array $values
+ * @return Builder
+ */
+ public function notInWhere($expr, $values) {}
+
+ /**
+ * Return the conditions for the query
+ *
+ * @return string|array
+ */
+ public function getWhere() {}
+
+ /**
+ * Sets a ORDER BY condition clause
+ *
+ * $builder->orderBy('Robots.name');
+ * $builder->orderBy(array('1', 'Robots.name'));
+ *
+ *
+ * @param string|array $orderBy
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function orderBy($orderBy) {}
+
+ /**
+ * Returns the set ORDER BY clause
+ *
+ * @return string|array
+ */
+ public function getOrderBy() {}
+
+ /**
+ * Sets a HAVING condition clause. You need to escape PHQL reserved words using [ and ] delimiters
+ *
+ * $builder->having('SUM(Robots.price) > 0');
+ *
+ *
+ * @param string $having
+ * @return Builder
+ */
+ public function having($having) {}
+
+ /**
+ * Sets a FOR UPDATE clause
+ *
+ * $builder->forUpdate(true);
+ *
+ *
+ * @param bool $forUpdate
+ * @return Builder
+ */
+ public function forUpdate($forUpdate) {}
+
+ /**
+ * Return the current having clause
+ *
+ * @return string|array
+ */
+ public function getHaving() {}
+
+ /**
+ * Sets a LIMIT clause, optionally a offset clause
+ *
+ * $builder->limit(100);
+ * $builder->limit(100, 20);
+ *
+ *
+ * @param int $limit
+ * @param int $offset
+ * @return Builder
+ */
+ public function limit($limit = null, $offset = null) {}
+
+ /**
+ * Returns the current LIMIT clause
+ *
+ * @return string|array
+ */
+ public function getLimit() {}
+
+ /**
+ * Sets an OFFSET clause
+ *
+ * $builder->offset(30);
+ *
+ *
+ * @param int $offset
+ * @return Builder
+ */
+ public function offset($offset) {}
+
+ /**
+ * Returns the current OFFSET clause
+ *
+ * @return string|array
+ */
+ public function getOffset() {}
+
+ /**
+ * Sets a GROUP BY clause
+ *
+ * $builder->groupBy(array('Robots.name'));
+ *
+ *
+ * @param string|array $group
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function groupBy($group) {}
+
+ /**
+ * Returns the GROUP BY clause
+ *
+ * @return string
+ */
+ public function getGroupBy() {}
+
+ /**
+ * Returns a PHQL statement built based on the builder parameters
+ *
+ * @return string
+ */
+ public final function getPhql() {}
+
+ /**
+ * Returns the query built
+ *
+ * @return \Phalcon\Mvc\Model\Query
+ */
+ public function getQuery() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/query/BuilderInterface.php b/ide/2.0.6/Phalcon/mvc/model/query/BuilderInterface.php
new file mode 100644
index 000000000..9e8b04895
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/query/BuilderInterface.php
@@ -0,0 +1,249 @@
+
+ * $intermediate = Phalcon\Mvc\Model\Query\Lang::parsePHQL("SELECT r.* FROM Robots r LIMIT 10");
+ *
+ */
+abstract class Lang
+{
+
+ /**
+ * Parses a PHQL statement returning an intermediate representation (IR)
+ *
+ * @param string $phql
+ * @return string
+ */
+ public static function parsePHQL($phql) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/query/Status.php b/ide/2.0.6/Phalcon/mvc/model/query/Status.php
new file mode 100644
index 000000000..44bd6423d
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/query/Status.php
@@ -0,0 +1,63 @@
+
+ * $phql = "UPDATE Robots SET name = :name:, type = :type:, year = :year: WHERE id = :id:";
+ * $status = $app->modelsManager->executeQuery($phql, array(
+ * 'id' => 100,
+ * 'name' => 'Astroy Boy',
+ * 'type' => 'mechanical',
+ * 'year' => 1959
+ * ));
+ * \//Check if the update was successful
+ * if ($status->success() == true) {
+ * echo 'OK';
+ * }
+ *
+ */
+class Status implements \Phalcon\Mvc\Model\Query\StatusInterface
+{
+
+ protected $_success;
+
+
+ protected $_model;
+
+
+ /**
+ * Phalcon\Mvc\Model\Query\Status
+ *
+ * @param bool $success
+ * @param mixed $model
+ */
+ public function __construct($success, \Phalcon\Mvc\ModelInterface $model = null) {}
+
+ /**
+ * Returns the model that executed the action
+ *
+ * @return \Phalcon\Mvc\ModelInterface
+ */
+ public function getModel() {}
+
+ /**
+ * Returns the messages produced because of a failed operation
+ *
+ * @return \Phalcon\Mvc\Model\MessageInterface
+ */
+ public function getMessages() {}
+
+ /**
+ * Allows to check if the executed operation was successful
+ *
+ * @return bool
+ */
+ public function success() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/query/StatusInterface.php b/ide/2.0.6/Phalcon/mvc/model/query/StatusInterface.php
new file mode 100644
index 000000000..9b1b58318
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/query/StatusInterface.php
@@ -0,0 +1,41 @@
+
+ * try {
+ * use Phalcon\Mvc\Model\Transaction\Manager as TransactionManager;
+ * $transactionManager = new TransactionManager();
+ * $transaction = $transactionManager->get();
+ * $robot = new Robots();
+ * $robot->setTransaction($transaction);
+ * $robot->name = 'WALL·E';
+ * $robot->created_at = date('Y-m-d');
+ * if($robot->save()==false){
+ * $transaction->rollback("Can't save robot");
+ * }
+ * $robotPart = new RobotParts();
+ * $robotPart->setTransaction($transaction);
+ * $robotPart->type = 'head';
+ * if($robotPart->save()==false){
+ * $transaction->rollback("Can't save robot part");
+ * }
+ * $transaction->commit();
+ * } catch (Phalcon\Mvc\Model\Transaction\Failed $e) {
+ * echo 'Failed, reason: ', $e->getMessage();
+ * }
+ *
+ */
+class Manager implements \Phalcon\Mvc\Model\Transaction\ManagerInterface, \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_initialized = false;
+
+
+ protected $_rollbackPendent = true;
+
+
+ protected $_number = 0;
+
+
+ protected $_service = "db";
+
+
+ protected $_transactions;
+
+
+ /**
+ * Phalcon\Mvc\Model\Transaction\Manager constructor
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function __construct(\Phalcon\DiInterface $dependencyInjector = null) {}
+
+ /**
+ * Sets the dependency injection container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the dependency injection container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the database service used to run the isolated transactions
+ *
+ * @param string $service
+ * @return Manager
+ */
+ public function setDbService($service) {}
+
+ /**
+ * Returns the database service used to isolate the transaction
+ *
+ * @return string
+ */
+ public function getDbService() {}
+
+ /**
+ * Set if the transaction manager must register a shutdown function to clean up pendent transactions
+ *
+ * @param bool $rollbackPendent
+ * @return Manager
+ */
+ public function setRollbackPendent($rollbackPendent) {}
+
+ /**
+ * Check if the transaction manager is registering a shutdown function to clean up pendent transactions
+ *
+ * @return bool
+ */
+ public function getRollbackPendent() {}
+
+ /**
+ * Checks whether the manager has an active transaction
+ *
+ * @return bool
+ */
+ public function has() {}
+
+ /**
+ * Returns a new \Phalcon\Mvc\Model\Transaction or an already created once
+ * This method registers a shutdown function to rollback active connections
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function get($autoBegin = true) {}
+
+ /**
+ * Create/Returns a new transaction or an existing one
+ *
+ * @param bool $autoBegin
+ * @return \Phalcon\Mvc\Model\TransactionInterface
+ */
+ public function getOrCreateTransaction($autoBegin = true) {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ */
+ public function rollbackPendent() {}
+
+ /**
+ * Commmits active transactions within the manager
+ */
+ public function commit() {}
+
+ /**
+ * Rollbacks active transactions within the manager
+ * Collect will remove the transaction from the manager
+ *
+ * @param boolean $collect
+ */
+ public function rollback($collect = true) {}
+
+ /**
+ * Notifies the manager about a rollbacked transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyRollback(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Notifies the manager about a commited transaction
+ *
+ * @param mixed $transaction
+ */
+ public function notifyCommit(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Removes transactions from the TransactionManager
+ *
+ * @param mixed $transaction
+ */
+ protected function _collectTransaction(\Phalcon\Mvc\Model\TransactionInterface $transaction) {}
+
+ /**
+ * Remove all the transactions from the manager
+ */
+ public function collectTransactions() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/transaction/ManagerInterface.php b/ide/2.0.6/Phalcon/mvc/model/transaction/ManagerInterface.php
new file mode 100644
index 000000000..5fc97d481
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/transaction/ManagerInterface.php
@@ -0,0 +1,71 @@
+
+ * use Phalcon\Mvc\Model\Validator\Email as EmailValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new EmailValidator(array(
+ * 'field' => 'electronic_mail'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Email extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Email() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/Exclusionin.php b/ide/2.0.6/Phalcon/mvc/model/validator/Exclusionin.php
new file mode 100644
index 000000000..472e40659
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/Exclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\ExclusionIn as ExclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new ExclusionInValidator(array(
+ * 'field' => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Exclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Exclusionin() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/Inclusionin.php b/ide/2.0.6/Phalcon/mvc/model/validator/Inclusionin.php
new file mode 100644
index 000000000..885a18695
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/Inclusionin.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\InclusionIn as InclusionInValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new InclusionInValidator(array(
+ * "field" => 'status',
+ * 'domain' => array('A', 'I')
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Inclusionin extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Inclusionin() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/Ip.php b/ide/2.0.6/Phalcon/mvc/model/validator/Ip.php
new file mode 100644
index 000000000..68e669af5
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/Ip.php
@@ -0,0 +1,62 @@
+
+ * use Phalcon\Mvc\Model\Validator\Ip;
+ * class Data extends Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * // Any pubic IP
+ * $this->validate(new IP(array(
+ * 'field' => 'server_ip',
+ * 'version' => IP::VERSION_4 | IP::VERSION_6, // v6 and v4. The same if not specified
+ * 'allowReserved' => false, // False if not specified. Ignored for v6
+ * 'allowPrivate' => false, // False if not specified
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * // Any public v4 address
+ * $this->validate(new IP(array(
+ * 'field' => 'ip_4',
+ * 'version' => IP::VERSION_4,
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * // Any v6 address
+ * $this->validate(new IP(array(
+ * 'field' => 'ip6',
+ * 'version' => IP::VERSION_6,
+ * 'allowPrivate' => true,
+ * 'message' => 'IP address has to be correct'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Ip extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ const VERSION_4 = 1048576;
+
+
+ const VERSION_6 = 2097152;
+
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Ip() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/Numericality.php b/ide/2.0.6/Phalcon/mvc/model/validator/Numericality.php
new file mode 100644
index 000000000..3e8ee0c64
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/Numericality.php
@@ -0,0 +1,38 @@
+
+ * use Phalcon\Mvc\Model\Validator\Numericality as NumericalityValidator;
+ * class Products extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new NumericalityValidator(array(
+ * "field" => 'price'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Numericality extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Numericality() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/PresenceOf.php b/ide/2.0.6/Phalcon/mvc/model/validator/PresenceOf.php
new file mode 100644
index 000000000..97471fec4
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/PresenceOf.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\PresenceOf;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new PresenceOf(array(
+ * "field" => 'name',
+ * "message" => 'The name is required'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class PresenceOf extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_PresenceOf() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/Regex.php b/ide/2.0.6/Phalcon/mvc/model/validator/Regex.php
new file mode 100644
index 000000000..c89d1e5b1
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/Regex.php
@@ -0,0 +1,39 @@
+
+ * use Phalcon\Mvc\Model\Validator\Regex as RegexValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new RegexValidator(array(
+ * "field" => 'created_at',
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])/'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Regex extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Regex() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/StringLength.php b/ide/2.0.6/Phalcon/mvc/model/validator/StringLength.php
new file mode 100644
index 000000000..b1588c7b5
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/StringLength.php
@@ -0,0 +1,42 @@
+
+ * use Phalcon\Mvc\Model\Validator\StringLength as StringLengthValidator;
+ * class Subscriptors extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new StringLengthValidator(array(
+ * "field" => 'name_last',
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class StringLength extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_StringLength() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/Uniqueness.php b/ide/2.0.6/Phalcon/mvc/model/validator/Uniqueness.php
new file mode 100644
index 000000000..1a5105ca0
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/Uniqueness.php
@@ -0,0 +1,41 @@
+
+ * use Phalcon\Mvc\Model;
+ * use Phalcon\Mvc\Model\Validator\Uniqueness;
+ * class Subscriptors extends Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new Uniqueness(array(
+ * "field" => "email",
+ * "message" => "Value of field 'email' is already present in another record"
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Uniqueness extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Uniqueness() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/model/validator/Url.php b/ide/2.0.6/Phalcon/mvc/model/validator/Url.php
new file mode 100644
index 000000000..9579116c2
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/model/validator/Url.php
@@ -0,0 +1,38 @@
+
+ * use Phalcon\Mvc\Model\Validator\Url as UrlValidator;
+ * class Posts extends \Phalcon\Mvc\Model
+ * {
+ * public function validation()
+ * {
+ * $this->validate(new UrlValidator(array(
+ * 'field' => 'source_url'
+ * )));
+ * if ($this->validationHasFailed() == true) {
+ * return false;
+ * }
+ * }
+ * }
+ *
+ */
+class Url extends \Phalcon\Mvc\Model\Validator implements \Phalcon\Mvc\Model\ValidatorInterface
+{
+
+ /**
+ * Executes the validator
+ *
+ * @param mixed $record
+ * @return bool
+ */
+ public function validate(\Phalcon\Mvc\EntityInterface $record) {}
+
+
+ function zephir_init_properties_Phalcon_Mvc_Model_Validator_Url() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/router/Annotations.php b/ide/2.0.6/Phalcon/mvc/router/Annotations.php
new file mode 100644
index 000000000..20343fb9d
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/router/Annotations.php
@@ -0,0 +1,105 @@
+
+ * $di['router'] = function() {
+ * //Use the annotations router
+ * $router = new Annotations(false);
+ * //This will do the same as above but only if the handled uri starts with /robots
+ * $router->addResource('Robots', '/robots');
+ * return $router;
+ * };
+ *
+ */
+class Annotations extends \Phalcon\Mvc\Router
+{
+
+ protected $_handlers;
+
+
+ protected $_processed = false;
+
+
+ protected $_controllerSuffix = "Controller";
+
+
+ protected $_actionSuffix = "Action";
+
+
+ protected $_routePrefix;
+
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ *
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addResource($handler, $prefix = null) {}
+
+ /**
+ * Adds a resource to the annotations handler
+ * A resource is a class that contains routing annotations
+ * The class is located in a module
+ *
+ * @param string $module
+ * @param string $handler
+ * @param string $prefix
+ * @return Annotations
+ */
+ public function addModuleResource($module, $handler, $prefix = null) {}
+
+ /**
+ * Produce the routing parameters from the rewrite information
+ *
+ * @param string $uri
+ */
+ public function handle($uri = null) {}
+
+ /**
+ * Checks for annotations in the controller docblock
+ *
+ * @param string $handler
+ * @param mixed $annotation
+ */
+ public function processControllerAnnotation($handler, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Checks for annotations in the public methods of the controller
+ *
+ * @param string $module
+ * @param string $namespaceName
+ * @param string $controller
+ * @param string $action
+ * @param \Phalcon\Annotations\Annotation $annotation
+ */
+ public function processActionAnnotation($module, $namespaceName, $controller, $action, \Phalcon\Annotations\Annotation $annotation) {}
+
+ /**
+ * Changes the controller class suffix
+ *
+ * @param string $controllerSuffix
+ */
+ public function setControllerSuffix($controllerSuffix) {}
+
+ /**
+ * Changes the action method suffix
+ *
+ * @param string $actionSuffix
+ */
+ public function setActionSuffix($actionSuffix) {}
+
+ /**
+ * Return the registered resources
+ *
+ * @return array
+ */
+ public function getResources() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/router/Exception.php b/ide/2.0.6/Phalcon/mvc/router/Exception.php
new file mode 100644
index 000000000..e8a40f672
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/router/Exception.php
@@ -0,0 +1,12 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+class Group implements \Phalcon\Mvc\Router\GroupInterface
+{
+
+ protected $_prefix;
+
+
+ protected $_hostname;
+
+
+ protected $_paths;
+
+
+ protected $_routes;
+
+
+ protected $_beforeMatch;
+
+
+ /**
+ * Phalcon\Mvc\Router\Group constructor
+ *
+ * @param mixed $paths
+ */
+ public function __construct($paths = null) {}
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix) {}
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix() {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param mixed $paths
+ * @return GroupInterface
+ */
+ public function setPaths($paths) {}
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return RouteInterface
+ */
+ public function getRoutes() {}
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addGet($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPost($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPut($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addPatch($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addDelete($pattern, $paths = null) {}
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addOptions($pattern, $paths = null) {}
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param string/array $paths
+ * @return \Phalcon\Mvc\Router\Route
+ */
+ public function addHead($pattern, $paths = null) {}
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear() {}
+
+ /**
+ * Adds a route applying the common attributes
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return RouteInterface
+ */
+ protected function _addRoute($pattern, $paths = null, $httpMethods = null) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/router/GroupInterface.php b/ide/2.0.6/Phalcon/mvc/router/GroupInterface.php
new file mode 100644
index 000000000..bd9481889
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/router/GroupInterface.php
@@ -0,0 +1,186 @@
+
+ * $router = new \Phalcon\Mvc\Router();
+ * //Create a group with a common module and controller
+ * $blog = new Group(array(
+ * 'module' => 'blog',
+ * 'controller' => 'index'
+ * ));
+ * //All the routes start with /blog
+ * $blog->setPrefix('/blog');
+ * //Add a route to the group
+ * $blog->add('/save', array(
+ * 'action' => 'save'
+ * ));
+ * //Add another route to the group
+ * $blog->add('/edit/{id}', array(
+ * 'action' => 'edit'
+ * ));
+ * //This route maps to a controller different than the default
+ * $blog->add('/blog', array(
+ * 'controller' => 'about',
+ * 'action' => 'index'
+ * ));
+ * //Add the group to the router
+ * $router->mount($blog);
+ *
+ */
+interface GroupInterface
+{
+
+ /**
+ * Set a hostname restriction for all the routes in the group
+ *
+ * @param string $hostname
+ * @return GroupInterface
+ */
+ public function setHostname($hostname);
+
+ /**
+ * Returns the hostname restriction
+ *
+ * @return string
+ */
+ public function getHostname();
+
+ /**
+ * Set a common uri prefix for all the routes in this group
+ *
+ * @param string $prefix
+ * @return GroupInterface
+ */
+ public function setPrefix($prefix);
+
+ /**
+ * Returns the common prefix for all the routes
+ *
+ * @return string
+ */
+ public function getPrefix();
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $beforeMatch
+ * @return GroupInterface
+ */
+ public function beforeMatch($beforeMatch);
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch();
+
+ /**
+ * Set common paths for all the routes in the group
+ *
+ * @param array $paths
+ * @return \Phalcon\Mvc\Router\Group
+ */
+ public function setPaths($paths);
+
+ /**
+ * Returns the common paths defined for this group
+ *
+ * @return array|string
+ */
+ public function getPaths();
+
+ /**
+ * Returns the routes added to the group
+ *
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function getRoutes();
+
+ /**
+ * Adds a route to the router on any HTTP method
+ *
+ * router->add('/about', 'About::index');
+ *
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @param mixed $httpMethods
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function add($pattern, $paths = null, $httpMethods = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is GET
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addGet($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is POST
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPost($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PUT
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPut($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is PATCH
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addPatch($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is DELETE
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addDelete($pattern, $paths = null);
+
+ /**
+ * Add a route to the router that only match if the HTTP method is OPTIONS
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addOptions($pattern, $paths = null);
+
+ /**
+ * Adds a route to the router that only match if the HTTP method is HEAD
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ * @return \Phalcon\Mvc\Router\RouteInterface
+ */
+ public function addHead($pattern, $paths = null);
+
+ /**
+ * Removes all the pre-defined routes
+ */
+ public function clear();
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/router/Route.php b/ide/2.0.6/Phalcon/mvc/router/Route.php
new file mode 100644
index 000000000..5cb392f08
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/router/Route.php
@@ -0,0 +1,243 @@
+
+ * $route->via('GET');
+ * $route->via(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function via($httpMethods) {}
+
+ /**
+ * Extracts parameters from a string
+ *
+ * @param string $pattern
+ * @return array|bool
+ */
+ public function extractNamedParams($pattern) {}
+
+ /**
+ * Reconfigure the route adding a new pattern and a set of paths
+ *
+ * @param string $pattern
+ * @param mixed $paths
+ */
+ public function reConfigure($pattern, $paths = null) {}
+
+ /**
+ * Returns routePaths
+ *
+ * @param mixed $paths
+ * @return array
+ */
+ public static function getRoutePaths($paths = null) {}
+
+ /**
+ * Returns the route's name
+ *
+ * @return string
+ */
+ public function getName() {}
+
+ /**
+ * Sets the route's name
+ *
+ * $router->add('/about', array(
+ * 'controller' => 'about'
+ * ))->setName('about');
+ *
+ *
+ * @param string $name
+ * @return Route
+ */
+ public function setName($name) {}
+
+ /**
+ * Sets a callback that is called if the route is matched.
+ * The developer can implement any arbitrary conditions here
+ * If the callback returns false the route is treated as not matched
+ *
+ * @param callable $callback
+ * @return Route
+ */
+ public function beforeMatch($callback) {}
+
+ /**
+ * Returns the 'before match' callback if any
+ *
+ * @return callable
+ */
+ public function getBeforeMatch() {}
+
+ /**
+ * Returns the route's id
+ *
+ * @return string
+ */
+ public function getRouteId() {}
+
+ /**
+ * Returns the route's pattern
+ *
+ * @return string
+ */
+ public function getPattern() {}
+
+ /**
+ * Returns the route's compiled pattern
+ *
+ * @return string
+ */
+ public function getCompiledPattern() {}
+
+ /**
+ * Returns the paths
+ *
+ * @return array
+ */
+ public function getPaths() {}
+
+ /**
+ * Returns the paths using positions as keys and names as values
+ *
+ * @return array
+ */
+ public function getReversedPaths() {}
+
+ /**
+ * Sets a set of HTTP methods that constraint the matching of the route (alias of via)
+ *
+ * $route->setHttpMethods('GET');
+ * $route->setHttpMethods(array('GET', 'POST'));
+ *
+ *
+ * @param mixed $httpMethods
+ * @return Route
+ */
+ public function setHttpMethods($httpMethods) {}
+
+ /**
+ * Returns the HTTP methods that constraint matching the route
+ *
+ * @return array|string
+ */
+ public function getHttpMethods() {}
+
+ /**
+ * Sets a hostname restriction to the route
+ *
+ * $route->setHostname('localhost');
+ *
+ *
+ * @param string $hostname
+ * @return Route
+ */
+ public function setHostname($hostname) {}
+
+ /**
+ * Returns the hostname restriction if any
+ *
+ * @return string
+ */
+ public function getHostname() {}
+
+ /**
+ * Sets the group associated with the route
+ *
+ * @param mixed $group
+ * @return Route
+ */
+ public function setGroup(GroupInterface $group) {}
+
+ /**
+ * Returns the group associated with the route
+ *
+ * @return null|GroupInterface
+ */
+ public function getGroup() {}
+
+ /**
+ * Adds a converter to perform an additional transformation for certain parameter
+ *
+ * @param string $name
+ * @param mixed $converter
+ * @return Route
+ */
+ public function convert($name, $converter) {}
+
+ /**
+ * Returns the router converter
+ *
+ * @return array
+ */
+ public function getConverters() {}
+
+ /**
+ * Resets the internal route id generator
+ */
+ public static function reset() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/router/RouteInterface.php b/ide/2.0.6/Phalcon/mvc/router/RouteInterface.php
new file mode 100644
index 000000000..e49f3af1d
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/router/RouteInterface.php
@@ -0,0 +1,113 @@
+
+ * $view = new \Phalcon\Mvc\View\Simple();
+ * echo $view->render('templates/my-view', array('content' => $html));
+ * //or with filename with extension
+ * echo $view->render('templates/my-view.volt', array('content' => $html));
+ *
+ */
+class Simple extends \Phalcon\Di\Injectable implements \Phalcon\Mvc\ViewBaseInterface
+{
+
+ protected $_options;
+
+
+ protected $_viewsDir;
+
+
+ protected $_partialsDir;
+
+
+ protected $_viewParams;
+
+
+ protected $_engines = false;
+
+
+ protected $_registeredEngines;
+
+
+ protected $_activeRenderPath;
+
+
+ protected $_content;
+
+
+ protected $_cache = false;
+
+
+ protected $_cacheOptions;
+
+
+
+ public function getRegisteredEngines() {}
+
+ /**
+ * Phalcon\Mvc\View\Simple constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = null) {}
+
+ /**
+ * Sets views directory. Depending of your platform, always add a trailing slash or backslash
+ *
+ * @param string $viewsDir
+ */
+ public function setViewsDir($viewsDir) {}
+
+ /**
+ * Gets views directory
+ *
+ * @return string
+ */
+ public function getViewsDir() {}
+
+ /**
+ * Register templating engines
+ *
+ * $this->view->registerEngines(array(
+ * ".phtml" => "Phalcon\Mvc\View\Engine\Php",
+ * ".volt" => "Phalcon\Mvc\View\Engine\Volt",
+ * ".mhtml" => "MyCustomEngine"
+ * ));
+ *
+ *
+ * @param array $engines
+ */
+ public function registerEngines($engines) {}
+
+ /**
+ * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
+ *
+ * @return array
+ */
+ protected function _loadTemplateEngines() {}
+
+ /**
+ * Tries to render the view with every engine registered in the component
+ *
+ * @param string $path
+ * @param array $params
+ */
+ protected final function _internalRender($path, $params) {}
+
+ /**
+ * Renders a view
+ *
+ * @param string $path
+ * @param array $params
+ * @return string
+ */
+ public function render($path, $params = null) {}
+
+ /**
+ * Renders a partial view
+ *
+ * //Show a partial inside another view
+ * $this->partial('shared/footer');
+ *
+ *
+ * //Show a partial inside another view with parameters
+ * $this->partial('shared/footer', array('content' => $html));
+ *
+ *
+ * @param string $partialPath
+ * @param array $params
+ */
+ public function partial($partialPath, $params = null) {}
+
+ /**
+ * Sets the cache options
+ *
+ * @param array $options
+ * @return \Phalcon\Mvc\View\Simple
+ */
+ public function setCacheOptions($options) {}
+
+ /**
+ * Returns the cache options
+ *
+ * @return array
+ */
+ public function getCacheOptions() {}
+
+ /**
+ * Create a Phalcon\Cache based on the internal cache options
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ protected function _createCache() {}
+
+ /**
+ * Returns the cache instance used to cache
+ *
+ * @return \Phalcon\Cache\BackendInterface
+ */
+ public function getCache() {}
+
+ /**
+ * Cache the actual view render to certain level
+ *
+ * $this->view->cache(array('key' => 'my-key', 'lifetime' => 86400));
+ *
+ *
+ * @param mixed $options
+ * @return Simple
+ */
+ public function cache($options = true) {}
+
+ /**
+ * Adds parameters to views (alias of setVar)
+ *
+ * $this->view->setParamToView('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setParamToView($key, $value) {}
+
+ /**
+ * Set all the render params
+ *
+ * $this->view->setVars(array('products' => $products));
+ *
+ *
+ * @param array $params
+ * @param bool $merge
+ * @return Simple
+ */
+ public function setVars($params, $merge = true) {}
+
+ /**
+ * Set a single view parameter
+ *
+ * $this->view->setVar('products', $products);
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ * @return Simple
+ */
+ public function setVar($key, $value) {}
+
+ /**
+ * Returns a parameter previously set in the view
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function getVar($key) {}
+
+ /**
+ * Returns parameters to views
+ *
+ * @return array
+ */
+ public function getParamsToView() {}
+
+ /**
+ * Externally sets the view content
+ *
+ * $this->view->setContent("hello
");
+ *
+ *
+ * @param string $content
+ * @return Simple
+ */
+ public function setContent($content) {}
+
+ /**
+ * Returns cached output from another view stage
+ *
+ * @return string
+ */
+ public function getContent() {}
+
+ /**
+ * Returns the path of the view that is currently rendered
+ *
+ * @return string
+ */
+ public function getActiveRenderPath() {}
+
+ /**
+ * Magic method to pass variables to the views
+ *
+ * $this->view->products = $products;
+ *
+ *
+ * @param string $key
+ * @param mixed $value
+ */
+ public function __set($key, $value) {}
+
+ /**
+ * Magic method to retrieve a variable passed to the view
+ *
+ * echo $this->view->products;
+ *
+ *
+ * @param string $key
+ * @return mixed
+ */
+ public function __get($key) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/mvc/view/engine/Php.php b/ide/2.0.6/Phalcon/mvc/view/engine/Php.php
new file mode 100644
index 000000000..d554be8de
--- /dev/null
+++ b/ide/2.0.6/Phalcon/mvc/view/engine/Php.php
@@ -0,0 +1,21 @@
+
+ * $compiler = new \Phalcon\Mvc\View\Engine\Volt\Compiler();
+ * $compiler->compile('views/partials/header.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ */
+class Compiler implements \Phalcon\Di\InjectionAwareInterface
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_view;
+
+
+ protected $_options;
+
+
+ protected $_arrayHelpers;
+
+
+ protected $_level = 0;
+
+
+ protected $_foreachLevel = 0;
+
+
+ protected $_blockLevel = 0;
+
+
+ protected $_exprLevel = 0;
+
+
+ protected $_extended = false;
+
+
+ protected $_autoescape = false;
+
+
+ protected $_extendedBlocks;
+
+
+ protected $_currentBlock;
+
+
+ protected $_blocks;
+
+
+ protected $_forElsePointers;
+
+
+ protected $_loopPointers;
+
+
+ protected $_extensions;
+
+
+ protected $_functions;
+
+
+ protected $_filters;
+
+
+ protected $_macros;
+
+
+ protected $_prefix;
+
+
+ protected $_currentPath;
+
+
+ protected $_compiledTemplatePath;
+
+
+ /**
+ * Phalcon\Mvc\View\Engine\Volt\Compiler
+ *
+ * @param mixed $view
+ */
+ public function __construct(\Phalcon\Mvc\ViewBaseInterface $view = null) {}
+
+ /**
+ * Sets the dependency injector
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the internal dependency injector
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Sets the compiler options
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Sets a single compiler option
+ *
+ * @param string $option
+ * @param mixed $value
+ */
+ public function setOption($option, $value) {}
+
+ /**
+ * Returns a compiler's option
+ *
+ * @param string $option
+ * @return string
+ */
+ public function getOption($option) {}
+
+ /**
+ * Returns the compiler options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+ * Fires an event to registered extensions
+ *
+ * @param string $name
+ * @param array $arguments
+ * @return mixed
+ */
+ public final function fireExtensionEvent($name, $arguments = null) {}
+
+ /**
+ * Registers a Volt's extension
+ *
+ * @param mixed $extension
+ * @return Compiler
+ */
+ public function addExtension($extension) {}
+
+ /**
+ * Returns the list of extensions registered in Volt
+ *
+ * @return array
+ */
+ public function getExtensions() {}
+
+ /**
+ * Register a new function in the compiler
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return Compiler
+ */
+ public function addFunction($name, $definition) {}
+
+ /**
+ * Register the user registered functions
+ *
+ * @return array
+ */
+ public function getFunctions() {}
+
+ /**
+ * Register a new filter in the compiler
+ *
+ * @param string $name
+ * @param mixed $definition
+ * @return Compiler
+ */
+ public function addFilter($name, $definition) {}
+
+ /**
+ * Register the user registered filters
+ *
+ * @return array
+ */
+ public function getFilters() {}
+
+ /**
+ * Set a unique prefix to be used as prefix for compiled variables
+ *
+ * @param string $prefix
+ * @return Compiler
+ */
+ public function setUniquePrefix($prefix) {}
+
+ /**
+ * Return a unique prefix to be used as prefix for compiled variables and contexts
+ *
+ * @return string
+ */
+ public function getUniquePrefix() {}
+
+ /**
+ * Resolves attribute reading
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function attributeReader($expr) {}
+
+ /**
+ * Resolves function intermediate code into PHP function calls
+ *
+ * @param array $expr
+ * @return string
+ */
+ public function functionCall($expr) {}
+
+ /**
+ * Resolves filter intermediate code into a valid PHP expression
+ *
+ * @param array $test
+ * @param string $left
+ * @return string
+ */
+ public function resolveTest($test, $left) {}
+
+ /**
+ * Resolves filter intermediate code into PHP function calls
+ *
+ * @param array $filter
+ * @param string $left
+ * @return string
+ */
+ final protected function resolveFilter($filter, $left) {}
+
+ /**
+ * Resolves an expression node in an AST volt tree
+ *
+ * @param array $expr
+ * @return string
+ */
+ final public function expression($expr) {}
+
+ /**
+ * Compiles a block of statements
+ *
+ * @param array $statements
+ * @return string|array
+ */
+ final protected function _statementListOrExtends($statements) {}
+
+ /**
+ * Compiles a "foreach" intermediate code representation into plain PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileForeach($statement, $extendsMode = false) {}
+
+ /**
+ * Generates a 'forelse' PHP code
+ *
+ * @return string
+ */
+ public function compileForElse() {}
+
+ /**
+ * Compiles a 'if' statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileIf($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "elseif" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileElseIf($statement) {}
+
+ /**
+ * Compiles a "cache" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileCache($statement, $extendsMode = false) {}
+
+ /**
+ * Compiles a "set" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileSet($statement) {}
+
+ /**
+ * Compiles a "do" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileDo($statement) {}
+
+ /**
+ * Compiles a "return" statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileReturn($statement) {}
+
+ /**
+ * Compiles a "autoescape" statement returning PHP code
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileAutoEscape($statement, $extendsMode) {}
+
+ /**
+ * Compiles a '{{' '}}' statement returning PHP code
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileEcho($statement) {}
+
+ /**
+ * Compiles a 'include' statement returning PHP code
+ *
+ * @param array $statement
+ * @return string
+ */
+ public function compileInclude($statement) {}
+
+ /**
+ * Compiles macros
+ *
+ * @param array $statement
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileMacro($statement, $extendsMode) {}
+
+ /**
+ * Compiles calls to macros
+ *
+ * @param array $statement
+ * @param boolean $extendsMode
+ * @return string
+ */
+ public function compileCall($statement, $extendsMode) {}
+
+ /**
+ * Traverses a statement list compiling each of its nodes
+ *
+ * @param array $statements
+ * @param bool $extendsMode
+ * @return string
+ */
+ final protected function _statementList($statements, $extendsMode = false) {}
+
+ /**
+ * Compiles a Volt source code returning a PHP plain version
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ protected function _compileSource($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a string
+ *
+ * echo $compiler->compileString('{{ "hello world" }}');
+ *
+ *
+ * @param string $viewCode
+ * @param bool $extendsMode
+ * @return string
+ */
+ public function compileString($viewCode, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file forcing the destination path
+ *
+ * $compiler->compile('views/layouts/main.volt', 'views/layouts/main.volt.php');
+ *
+ *
+ * @param string $path
+ * @param string $compiledPath
+ * @param boolean $extendsMode
+ * @return string|array
+ */
+ public function compileFile($path, $compiledPath, $extendsMode = false) {}
+
+ /**
+ * Compiles a template into a file applying the compiler options
+ * This method does not return the compiled path if the template was not compiled
+ *
+ * $compiler->compile('views/layouts/main.volt');
+ * require $compiler->getCompiledTemplatePath();
+ *
+ *
+ * @param string $templatePath
+ * @param bool $extendsMode
+ */
+ public function compile($templatePath, $extendsMode = false) {}
+
+ /**
+ * Returns the path that is currently being compiled
+ *
+ * @return string
+ */
+ public function getTemplatePath() {}
+
+ /**
+ * Returns the path to the last compiled template
+ *
+ * @return string
+ */
+ public function getCompiledTemplatePath() {}
+
+ /**
+ * Parses a Volt template returning its intermediate representation
+ *
+ * print_r($compiler->parse('{{ 3 + 2 }}'));
+ *
+ *
+ * @param string $viewCode
+ * @return array
+ */
+ public function parse($viewCode) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/paginator/Adapter.php b/ide/2.0.6/Phalcon/paginator/Adapter.php
new file mode 100644
index 000000000..8a4dcf3fe
--- /dev/null
+++ b/ide/2.0.6/Phalcon/paginator/Adapter.php
@@ -0,0 +1,44 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\Model(
+ * array(
+ * "data" => Robots::find(),
+ * "limit" => 25,
+ * "page" => $currentPage
+ * )
+ * );
+ * $paginate = $paginator->getPaginate();
+ *
+ */
+class Model extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\Model constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdclass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/paginator/adapter/NativeArray.php b/ide/2.0.6/Phalcon/paginator/adapter/NativeArray.php
new file mode 100644
index 000000000..f080c16c1
--- /dev/null
+++ b/ide/2.0.6/Phalcon/paginator/adapter/NativeArray.php
@@ -0,0 +1,46 @@
+
+ * $paginator = new \Phalcon\Paginator\Adapter\NativeArray(
+ * array(
+ * "data" => array(
+ * array('id' => 1, 'name' => 'Artichoke'),
+ * array('id' => 2, 'name' => 'Carrots'),
+ * array('id' => 3, 'name' => 'Beet'),
+ * array('id' => 4, 'name' => 'Lettuce'),
+ * array('id' => 5, 'name' => '')
+ * ),
+ * "limit" => 2,
+ * "page" => $currentPage
+ * )
+ * );
+ *
+ */
+class NativeArray extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of the paginator
+ */
+ protected $_config = null;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\NativeArray constructor
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/paginator/adapter/QueryBuilder.php b/ide/2.0.6/Phalcon/paginator/adapter/QueryBuilder.php
new file mode 100644
index 000000000..3a6af396f
--- /dev/null
+++ b/ide/2.0.6/Phalcon/paginator/adapter/QueryBuilder.php
@@ -0,0 +1,69 @@
+
+ * $builder = $this->modelsManager->createBuilder()
+ * ->columns('id, name')
+ * ->from('Robots')
+ * ->orderBy('name');
+ * $paginator = new Phalcon\Paginator\Adapter\QueryBuilder(array(
+ * "builder" => $builder,
+ * "limit"=> 20,
+ * "page" => 1
+ * ));
+ *
+ */
+class QueryBuilder extends \Phalcon\Paginator\Adapter implements \Phalcon\Paginator\AdapterInterface
+{
+ /**
+ * Configuration of paginator by model
+ */
+ protected $_config;
+
+ /**
+ * Paginator's data
+ */
+ protected $_builder;
+
+
+ /**
+ * Phalcon\Paginator\Adapter\QueryBuilder
+ *
+ * @param array $config
+ */
+ public function __construct($config) {}
+
+ /**
+ * Get the current page number
+ *
+ * @return int
+ */
+ public function getCurrentPage() {}
+
+ /**
+ * Set query builder object
+ *
+ * @param mixed $builder
+ * @return QueryBuilder
+ */
+ public function setQueryBuilder(\Phalcon\Mvc\Model\Query\Builder $builder) {}
+
+ /**
+ * Get query builder object
+ *
+ * @return \Phalcon\Mvc\Model\Query\Builder
+ */
+ public function getQueryBuilder() {}
+
+ /**
+ * Returns a slice of the resultset to show in the pagination
+ *
+ * @return \stdClass
+ */
+ public function getPaginate() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/queue/Beanstalk.php b/ide/2.0.6/Phalcon/queue/Beanstalk.php
new file mode 100644
index 000000000..f5377b197
--- /dev/null
+++ b/ide/2.0.6/Phalcon/queue/Beanstalk.php
@@ -0,0 +1,135 @@
+
+ * $session->setOptions(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ *
+ *
+ * @param array $options
+ */
+ public function setOptions($options) {}
+
+ /**
+ * Get internal options
+ *
+ * @return array
+ */
+ public function getOptions() {}
+
+ /**
+ * Set session name
+ *
+ * @param string $name
+ */
+ public function setName($name) {}
+
+ /**
+ * Get session name
+ */
+ public function getName() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param bool $deleteOldSession
+ * @return Adapter
+ */
+ public function regenerateId($deleteOldSession = true) {}
+
+ /**
+ * Gets a session variable from an application context
+ *
+ * $session->get('auth', 'yes');
+ *
+ *
+ * @param string $index
+ * @param mixed $defaultValue
+ * @param bool $remove
+ */
+ public function get($index, $defaultValue = null, $remove = false) {}
+
+ /**
+ * Sets a session variable in an application context
+ *
+ * $session->set('auth', 'yes');
+ *
+ *
+ * @param string $index
+ * @param mixed $value
+ */
+ public function set($index, $value) {}
+
+ /**
+ * Check whether a session variable is set in an application context
+ *
+ * var_dump($session->has('auth'));
+ *
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function has($index) {}
+
+ /**
+ * Removes a session variable from an application context
+ *
+ * $session->remove('auth');
+ *
+ *
+ * @param string $index
+ */
+ public function remove($index) {}
+
+ /**
+ * Returns active session id
+ *
+ * echo $session->getId();
+ *
+ *
+ * @return string
+ */
+ public function getId() {}
+
+ /**
+ * Set the current session id
+ *
+ * $session->setId($id);
+ *
+ *
+ * @param string $id
+ */
+ public function setId($id) {}
+
+ /**
+ * Check whether the session has been started
+ *
+ * var_dump($session->isStarted());
+ *
+ *
+ * @return bool
+ */
+ public function isStarted() {}
+
+ /**
+ * Destroys the active session
+ *
+ * var_dump($session->destroy());
+ *
+ *
+ * @return bool
+ */
+ public function destroy() {}
+
+ /**
+ * Returns the status of the current session. For PHP 5.3 this function will always return SESSION_NONE
+ *
+ * var_dump($session->status());
+ * // PHP 5.4 and above will give meaningful messages, 5.3 gets SESSION_NONE always
+ * if ($session->status() !== $session::SESSION_ACTIVE) {
+ * $session->start();
+ * }
+ *
+ *
+ * @return int
+ */
+ public function status() {}
+
+ /**
+ * Alias: Gets a session variable from an application context
+ *
+ * @param string $index
+ */
+ public function __get($index) {}
+
+ /**
+ * Alias: Sets a session variable in an application context
+ *
+ * @param string $index
+ * @param mixed $value
+ */
+ public function __set($index, $value) {}
+
+ /**
+ * Alias: Check whether a session variable is set in an application context
+ *
+ * @param string $index
+ * @return bool
+ */
+ public function __isset($index) {}
+
+ /**
+ * Alias: Removes a session variable from an application context
+ *
+ * @param string $index
+ */
+ public function __unset($index) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/session/AdapterInterface.php b/ide/2.0.6/Phalcon/session/AdapterInterface.php
new file mode 100644
index 000000000..bd5c9c2d9
--- /dev/null
+++ b/ide/2.0.6/Phalcon/session/AdapterInterface.php
@@ -0,0 +1,91 @@
+
+ * $user = new \Phalcon\Session\Bag('user');
+ * $user->name = "Kimbra Johnson";
+ * $user->age = 22;
+ *
+ */
+class Bag implements \Phalcon\Di\InjectionAwareInterface, \Phalcon\Session\BagInterface, \IteratorAggregate, \ArrayAccess, \Countable
+{
+
+ protected $_dependencyInjector;
+
+
+ protected $_name = null;
+
+
+ protected $_data;
+
+
+ protected $_initialized = false;
+
+
+ protected $_session;
+
+
+ /**
+ * Phalcon\Session\Bag constructor
+ *
+ * @param string $name
+ */
+ public function __construct($name) {}
+
+ /**
+ * Sets the DependencyInjector container
+ *
+ * @param mixed $dependencyInjector
+ */
+ public function setDI(\Phalcon\DiInterface $dependencyInjector) {}
+
+ /**
+ * Returns the DependencyInjector container
+ *
+ * @return \Phalcon\DiInterface
+ */
+ public function getDI() {}
+
+ /**
+ * Initializes the session bag. This method must not be called directly, the class calls it when its internal data is accesed
+ */
+ public function initialize() {}
+
+ /**
+ * Destroyes the session bag
+ *
+ * $user->destroy();
+ *
+ */
+ public function destroy() {}
+
+ /**
+ * Sets a value in the session bag
+ *
+ * $user->set('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function set($property, $value) {}
+
+ /**
+ * Magic setter to assign values to the session bag
+ *
+ * $user->name = "Kimbra";
+ *
+ *
+ * @param string $property
+ * @param string $value
+ */
+ public function __set($property, $value) {}
+
+ /**
+ * Obtains a value from the session bag optionally setting a default value
+ *
+ * echo $user->get('name', 'Kimbra');
+ *
+ *
+ * @param string $property
+ * @param string $defaultValue
+ * @return mixed
+ */
+ public function get($property, $defaultValue = null) {}
+
+ /**
+ * Magic getter to obtain values from the session bag
+ *
+ * echo $user->name;
+ *
+ *
+ * @param string $property
+ * @return mixed
+ */
+ public function __get($property) {}
+
+ /**
+ * Check whether a property is defined in the internal bag
+ *
+ * var_dump($user->has('name'));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function has($property) {}
+
+ /**
+ * Magic isset to check whether a property is defined in the bag
+ *
+ * var_dump(isset($user['name']));
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __isset($property) {}
+
+ /**
+ * Removes a property from the internal bag
+ *
+ * $user->remove('name');
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function remove($property) {}
+
+ /**
+ * Magic unset to remove items using the array syntax
+ *
+ * unset($user['name']);
+ *
+ *
+ * @param string $property
+ * @return bool
+ */
+ public function __unset($property) {}
+
+ /**
+ * Return length of bag
+ *
+ * echo $user->count();
+ *
+ *
+ * @return int
+ */
+ public final function count() {}
+
+ /**
+ * Returns the bag iterator
+ *
+ * @return \ArrayIterator
+ */
+ public final function getIterator() {}
+
+ /**
+ * @param string $property
+ * @param mixed $value
+ */
+ public final function offsetSet($property, $value) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetExists($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetUnset($property) {}
+
+ /**
+ * @param string $property
+ */
+ public final function offsetGet($property) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/session/BagInterface.php b/ide/2.0.6/Phalcon/session/BagInterface.php
new file mode 100644
index 000000000..c36cc1973
--- /dev/null
+++ b/ide/2.0.6/Phalcon/session/BagInterface.php
@@ -0,0 +1,71 @@
+
+ * $session = new \Phalcon\Session\Adapter\Files(array(
+ * 'uniqueId' => 'my-private-app'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Files extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+}
diff --git a/ide/2.0.6/Phalcon/session/adapter/Libmemcached.php b/ide/2.0.6/Phalcon/session/adapter/Libmemcached.php
new file mode 100644
index 000000000..54ec0e0ad
--- /dev/null
+++ b/ide/2.0.6/Phalcon/session/adapter/Libmemcached.php
@@ -0,0 +1,88 @@
+
+ * $session = new Phalcon\Session\Adapter\Libmemcached(array(
+ * 'servers' => array(
+ * array('host' => 'localhost', 'port' => 11211, 'weight' => 1),
+ * ),
+ * 'client' => array(
+ * Memcached::OPT_HASH => Memcached::HASH_MD5,
+ * Memcached::OPT_PREFIX_KEY => 'prefix.',
+ * ),
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Libmemcached extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_libmemcached = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getLibmemcached() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Libmemcached constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options) {}
+
+ /**
+ * @return bool
+ */
+ public function open() {}
+
+ /**
+ * @return bool
+ */
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @return bool
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/session/adapter/Memcache.php b/ide/2.0.6/Phalcon/session/adapter/Memcache.php
new file mode 100644
index 000000000..f2436868b
--- /dev/null
+++ b/ide/2.0.6/Phalcon/session/adapter/Memcache.php
@@ -0,0 +1,79 @@
+
+ * $session = new \Phalcon\Session\Adapter\Memcache(array(
+ * 'uniqueId' => 'my-private-app',
+ * 'host' => '127.0.0.1',
+ * 'port' => 11211,
+ * 'persistent' => true,
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Memcache extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_memcache = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getMemcache() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Memcache constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = array()) {}
+
+
+ public function open() {}
+
+
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/session/adapter/Redis.php b/ide/2.0.6/Phalcon/session/adapter/Redis.php
new file mode 100644
index 000000000..fe6547bbf
--- /dev/null
+++ b/ide/2.0.6/Phalcon/session/adapter/Redis.php
@@ -0,0 +1,80 @@
+
+ * $session = new \Phalcon\Session\Adapter\Redis(array(
+ * 'uniqueId' => 'my-private-app',
+ * 'host' => 'localhost',
+ * 'port' => 6379,
+ * 'auth' => 'foobared',
+ * 'persistent' => false,
+ * 'lifetime' => 3600,
+ * 'prefix' => 'my_'
+ * ));
+ * $session->start();
+ * $session->set('var', 'some-value');
+ * echo $session->get('var');
+ *
+ */
+class Redis extends \Phalcon\Session\Adapter implements \Phalcon\Session\AdapterInterface
+{
+
+ protected $_redis = null;
+
+
+ protected $_lifetime = 8600;
+
+
+
+ public function getRedis() {}
+
+
+ public function getLifetime() {}
+
+ /**
+ * Phalcon\Session\Adapter\Redis constructor
+ *
+ * @param array $options
+ */
+ public function __construct($options = array()) {}
+
+
+ public function open() {}
+
+
+ public function close() {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return mixed
+ */
+ public function read($sessionId) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @param string $data
+ */
+ public function write($sessionId, $data) {}
+
+ /**
+ * {@inheritdoc}
+ *
+ * @param string $sessionId
+ * @return boolean
+ */
+ public function destroy($sessionId = null) {}
+
+ /**
+ * {@inheritdoc}
+ */
+ public function gc() {}
+
+}
diff --git a/ide/2.0.6/Phalcon/tag/Exception.php b/ide/2.0.6/Phalcon/tag/Exception.php
new file mode 100644
index 000000000..8d2604755
--- /dev/null
+++ b/ide/2.0.6/Phalcon/tag/Exception.php
@@ -0,0 +1,12 @@
+
+ * print_r($messages[0]);
+ *
+ *
+ * @param int $index
+ * @return \Phalcon\Validation\Message
+ */
+ public function offsetGet($index) {}
+
+ /**
+ * Sets an attribute using the array-syntax
+ *
+ * $messages[0] = new \Phalcon\Validation\Message('This is a message');
+ *
+ *
+ * @param int $index
+ * @param \Phalcon\Validation\Message $message
+ */
+ public function offsetSet($index, $message) {}
+
+ /**
+ * Checks if an index exists
+ *
+ * var_dump(isset($message['database']));
+ *
+ *
+ * @param int $index
+ * @return boolean
+ */
+ public function offsetExists($index) {}
+
+ /**
+ * Removes a message from the list
+ *
+ * unset($message['database']);
+ *
+ *
+ * @param string $index
+ */
+ public function offsetUnset($index) {}
+
+ /**
+ * Appends a message to the group
+ *
+ * $messages->appendMessage(new \Phalcon\Validation\Message('This is a message'));
+ *
+ *
+ * @param mixed $message
+ */
+ public function appendMessage(\Phalcon\Validation\MessageInterface $message) {}
+
+ /**
+ * Appends an array of messages to the group
+ *
+ * $messages->appendMessages($messagesArray);
+ *
+ *
+ * @param \Phalcon\Validation\MessageInterface[] $messages
+ */
+ public function appendMessages($messages) {}
+
+ /**
+ * Filters the message group by field name
+ *
+ * @param string $fieldName
+ * @return array
+ */
+ public function filter($fieldName) {}
+
+ /**
+ * Returns the number of messages in the list
+ *
+ * @return int
+ */
+ public function count() {}
+
+ /**
+ * Rewinds the internal iterator
+ */
+ public function rewind() {}
+
+ /**
+ * Returns the current message in the iterator
+ *
+ * @return \Phalcon\Validation\Message
+ */
+ public function current() {}
+
+ /**
+ * Returns the current position/key in the iterator
+ *
+ * @return int
+ */
+ public function key() {}
+
+ /**
+ * Moves the internal iteration pointer to the next position
+ */
+ public function next() {}
+
+ /**
+ * Check if the current message in the iterator is valid
+ *
+ * @return bool
+ */
+ public function valid() {}
+
+ /**
+ * Magic __set_state helps to re-build messages variable when exporting
+ *
+ * @param array $group
+ * @return \Phalcon\Validation\Message\Group
+ */
+ public static function __set_state($group) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Alnum.php b/ide/2.0.6/Phalcon/validation/validator/Alnum.php
new file mode 100644
index 000000000..96250226c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Alnum.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alnum as AlnumValidator;
+ * $validator->add('username', new AlnumValidator(array(
+ * 'message' => ':field must contain only alphanumeric characters'
+ * )));
+ *
+ */
+class Alnum extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Alpha.php b/ide/2.0.6/Phalcon/validation/validator/Alpha.php
new file mode 100644
index 000000000..3860505fd
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Alpha.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Alpha as AlphaValidator;
+ * $validator->add('username', new AlphaValidator(array(
+ * 'message' => ':field must contain only letters'
+ * )));
+ *
+ */
+class Alpha extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Between.php b/ide/2.0.6/Phalcon/validation/validator/Between.php
new file mode 100644
index 000000000..9a765abd7
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Between.php
@@ -0,0 +1,30 @@
+
+ * use Phalcon\Validation\Validator\Between;
+ * validator->add('name', new Between(array(
+ * 'minimum' => 0,
+ * 'maximum' => 100,
+ * 'message' => 'The price must be between 0 and 100'
+ * )));
+ *
+ */
+class Between extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Confirmation.php b/ide/2.0.6/Phalcon/validation/validator/Confirmation.php
new file mode 100644
index 000000000..75e1ac710
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Confirmation.php
@@ -0,0 +1,37 @@
+
+ * use Phalcon\Validation\Validator\Confirmation;
+ * $validator->add('password', new Confirmation(array(
+ * 'message' => 'Password doesn\'t match confirmation',
+ * 'with' => 'confirmPassword'
+ * )));
+ *
+ */
+class Confirmation extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+ /**
+ * Compare strings
+ *
+ * @param string $a
+ * @param string $b
+ * @return bool
+ */
+ protected final function compare($a, $b) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Digit.php b/ide/2.0.6/Phalcon/validation/validator/Digit.php
new file mode 100644
index 000000000..dae4e4dbe
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Digit.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Digit as DigitValidator;
+ * $validator->add('height', new DigitValidator(array(
+ * 'message' => ':field must be numeric'
+ * )));
+ *
+ */
+class Digit extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Email.php b/ide/2.0.6/Phalcon/validation/validator/Email.php
new file mode 100644
index 000000000..8951305fc
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Email.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Email as EmailValidator;
+ * $validator->add('email', new EmailValidator(array(
+ * 'message' => 'The e-mail is not valid'
+ * )));
+ *
+ */
+class Email extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/ExclusionIn.php b/ide/2.0.6/Phalcon/validation/validator/ExclusionIn.php
new file mode 100644
index 000000000..d6bd01efa
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/ExclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\ExclusionIn;
+ * $validator->add('status', new ExclusionIn(array(
+ * 'message' => 'The status must not be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class ExclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/File.php b/ide/2.0.6/Phalcon/validation/validator/File.php
new file mode 100644
index 000000000..96121dc85
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/File.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\File as FileValidator;
+ * $validator->add('file', new FileValidator(array(
+ * 'maxSize' => '2M',
+ * 'messageSize' => ':field exceeds the max filesize (:max)',
+ * 'allowedTypes' => array('image/jpeg', 'image/png'),
+ * 'messageType' => 'Allowed file types are :types',
+ * 'maxResolution' => '800x600',
+ * 'messageMaxResolution' => 'Max resolution of :field is :max'
+ * )));
+ *
+ */
+class File extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Identical.php b/ide/2.0.6/Phalcon/validation/validator/Identical.php
new file mode 100644
index 000000000..d5ee453cc
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Identical.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Identical;
+ * $validator->add('terms', new Identical(array(
+ * 'accepted' => 'yes',
+ * 'message' => 'Terms and conditions must be accepted'
+ * )));
+ *
+ */
+class Identical extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/InclusionIn.php b/ide/2.0.6/Phalcon/validation/validator/InclusionIn.php
new file mode 100644
index 000000000..4bee62023
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/InclusionIn.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\InclusionIn;
+ * $validator->add('status', new InclusionIn(array(
+ * 'message' => 'The status must be A or B',
+ * 'domain' => array('A', 'B')
+ * )));
+ *
+ */
+class InclusionIn extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Numericality.php b/ide/2.0.6/Phalcon/validation/validator/Numericality.php
new file mode 100644
index 000000000..5b68ec926
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Numericality.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Numericality;
+ * $validator->add('price', new Numericality(array(
+ * 'message' => ':field is not numeric'
+ * )));
+ *
+ */
+class Numericality extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/PresenceOf.php b/ide/2.0.6/Phalcon/validation/validator/PresenceOf.php
new file mode 100644
index 000000000..30ba729ed
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/PresenceOf.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\PresenceOf;
+ * $validator->add('name', new PresenceOf(array(
+ * 'message' => 'The name is required'
+ * )));
+ *
+ */
+class PresenceOf extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Regex.php b/ide/2.0.6/Phalcon/validation/validator/Regex.php
new file mode 100644
index 000000000..8b73552b6
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Regex.php
@@ -0,0 +1,28 @@
+
+ * use Phalcon\Validation\Validator\Regex as RegexValidator;
+ * $validator->add('created_at', new RegexValidator(array(
+ * 'pattern' => '/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/',
+ * 'message' => 'The creation date is invalid'
+ * )));
+ *
+ */
+class Regex extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/StringLength.php b/ide/2.0.6/Phalcon/validation/validator/StringLength.php
new file mode 100644
index 000000000..2bafa9675
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/StringLength.php
@@ -0,0 +1,32 @@
+
+ * use Phalcon\Validation\Validator\StringLength as StringLength;
+ * $validation->add('name_last', new StringLength(array(
+ * 'max' => 50,
+ * 'min' => 2,
+ * 'messageMaximum' => 'We don\'t like really long names',
+ * 'messageMinimum' => 'We want more than just their initials'
+ * )));
+ *
+ */
+class StringLength extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Uniqueness.php b/ide/2.0.6/Phalcon/validation/validator/Uniqueness.php
new file mode 100644
index 000000000..79ef4083c
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Uniqueness.php
@@ -0,0 +1,35 @@
+
+ * use Phalcon\Validation\Validator\Uniqueness as UniquenessValidator;
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'message' => ':field must be unique'
+ * )));
+ *
+ * Different attribute from the field
+ *
+ * $validator->add('username', new UniquenessValidator(array(
+ * 'model' => 'Users',
+ * 'attribute' => 'nick'
+ * )));
+ *
+ */
+class Uniqueness extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/ide/2.0.6/Phalcon/validation/validator/Url.php b/ide/2.0.6/Phalcon/validation/validator/Url.php
new file mode 100644
index 000000000..76ab65b91
--- /dev/null
+++ b/ide/2.0.6/Phalcon/validation/validator/Url.php
@@ -0,0 +1,27 @@
+
+ * use Phalcon\Validation\Validator\Url as UrlValidator;
+ * $validator->add('url', new UrlValidator(array(
+ * 'message' => ':field must be a url'
+ * )));
+ *
+ */
+class Url extends \Phalcon\Validation\Validator
+{
+
+ /**
+ * Executes the validation
+ *
+ * @param mixed $validation
+ * @param string $field
+ * @return bool
+ */
+ public function validate(\Phalcon\Validation $validation, $field) {}
+
+}
diff --git a/scripts/Phalcon/Builder/Model.php b/scripts/Phalcon/Builder/Model.php
index ed6afe434..b27f3b5fd 100644
--- a/scripts/Phalcon/Builder/Model.php
+++ b/scripts/Phalcon/Builder/Model.php
@@ -433,18 +433,19 @@ public function build()
$setters = array();
$getters = array();
foreach ($fields as $field) {
+ if (array_key_exists(strtolower($field->getName()), $exclude)) {
+ continue;
+ }
$type = $this->getPHPType($field->getType());
if ($useSettersGetters) {
- if (!array_key_exists(strtolower($field->getName()), $exclude)) {
- $attributes[] = $this->snippet->getAttributes($type, 'protected', $field->getName());
- $setterName = Utils::camelize($field->getName());
- $setters[] = $this->snippet->getSetter($field->getName(), $type, $setterName);
-
- if (isset($this->_typeMap[$type])) {
- $getters[] = $this->snippet->getGetterMap($field->getName(), $type, $setterName, $this->_typeMap[$type]);
- } else {
- $getters[] = $this->snippet->getGetter($field->getName(), $type, $setterName);
- }
+ $attributes[] = $this->snippet->getAttributes($type, 'protected', $field->getName());
+ $setterName = Utils::camelize($field->getName());
+ $setters[] = $this->snippet->getSetter($field->getName(), $type, $setterName);
+
+ if (isset($this->_typeMap[$type])) {
+ $getters[] = $this->snippet->getGetterMap($field->getName(), $type, $setterName, $this->_typeMap[$type]);
+ } else {
+ $getters[] = $this->snippet->getGetter($field->getName(), $type, $setterName);
}
} else {
$attributes[] = $this->snippet->getAttributes($type, 'public', $field->getName());
diff --git a/scripts/Phalcon/Builder/Path.php b/scripts/Phalcon/Builder/Path.php
index ec34bd6fe..74529e82e 100644
--- a/scripts/Phalcon/Builder/Path.php
+++ b/scripts/Phalcon/Builder/Path.php
@@ -92,9 +92,9 @@ public function setRootPath($path)
return $this;
}
- public function getRootPath($pathPath = null)
+ public function getRootPath($path = null)
{
- return $this->rootPath . ($pathPath ? trim($pathPath, '\\/') . DIRECTORY_SEPARATOR : '');
+ return $this->rootPath . ($path ? trim($path, '\\/') . DIRECTORY_SEPARATOR : '');
}
public function appendRootPath($pathPath)
diff --git a/scripts/Phalcon/Generator/Stub.php b/scripts/Phalcon/Generator/Stub.php
index eff22baf5..df44fbc3d 100644
--- a/scripts/Phalcon/Generator/Stub.php
+++ b/scripts/Phalcon/Generator/Stub.php
@@ -314,6 +314,5 @@ protected function _cleanup($dir)
rmdir($dir);
}
}
-
-$s = new Stub('phalcon', __DIR__ . '/../../../ide/phpstorm');
+$s = new Stub('phalcon', __DIR__ . '/../../../ide');
$s->generate();
diff --git a/scripts/Phalcon/Mvc/Model/Migration.php b/scripts/Phalcon/Mvc/Model/Migration.php
index 94be36de9..9a5fd1c6f 100644
--- a/scripts/Phalcon/Mvc/Model/Migration.php
+++ b/scripts/Phalcon/Mvc/Model/Migration.php
@@ -181,42 +181,60 @@ public static function generate($version, $table, $exportData=null)
$description = self::$_connection->describeColumns($table, $defaultSchema);
foreach ($description as $field) {
$fieldDefinition = array();
- switch ($field->getType()) {
- case Column::TYPE_INTEGER:
- $fieldDefinition[] = "'type' => Column::TYPE_INTEGER";
- $numericFields[$field->getName()] = true;
- break;
- case Column::TYPE_VARCHAR:
- $fieldDefinition[] = "'type' => Column::TYPE_VARCHAR";
- break;
- case Column::TYPE_CHAR:
- $fieldDefinition[] = "'type' => Column::TYPE_CHAR";
- break;
- case Column::TYPE_DATE:
- $fieldDefinition[] = "'type' => Column::TYPE_DATE";
- break;
- case Column::TYPE_DATETIME:
- $fieldDefinition[] = "'type' => Column::TYPE_DATETIME";
- break;
- case Column::TYPE_DECIMAL:
- $fieldDefinition[] = "'type' => Column::TYPE_DECIMAL";
- $numericFields[$field->getName()] = true;
- break;
- case Column::TYPE_TEXT:
- $fieldDefinition[] = "'type' => Column::TYPE_TEXT";
- break;
- case Column::TYPE_BOOLEAN:
- $fieldDefinition[] = "'type' => Column::TYPE_BOOLEAN";
- break;
- case Column::TYPE_FLOAT:
- $fieldDefinition[] = "'type' => Column::TYPE_FLOAT";
- break;
- case Column::TYPE_DOUBLE:
- $fieldDefinition[] = "'type' => Column::TYPE_DOUBLE";
- break;
- default:
- throw new Exception('Unrecognized data type ' . $field->getType() . ' at column ' . $field->getName());
- }
+ switch ($field->getType()) {
+ case Column::TYPE_INTEGER:
+ $fieldDefinition[] = "'type' => Column::TYPE_INTEGER";
+ $numericFields[ $field->getName() ] = true;
+ break;
+ case Column::TYPE_VARCHAR:
+ $fieldDefinition[] = "'type' => Column::TYPE_VARCHAR";
+ break;
+ case Column::TYPE_CHAR:
+ $fieldDefinition[] = "'type' => Column::TYPE_CHAR";
+ break;
+ case Column::TYPE_DATE:
+ $fieldDefinition[] = "'type' => Column::TYPE_DATE";
+ break;
+ case Column::TYPE_DATETIME:
+ $fieldDefinition[] = "'type' => Column::TYPE_DATETIME";
+ break;
+ case Column::TYPE_DECIMAL:
+ $fieldDefinition[] = "'type' => Column::TYPE_DECIMAL";
+ $numericFields[ $field->getName() ] = true;
+ break;
+ case Column::TYPE_TEXT:
+ $fieldDefinition[] = "'type' => Column::TYPE_TEXT";
+ break;
+ case Column::TYPE_BOOLEAN:
+ $fieldDefinition[] = "'type' => Column::TYPE_BOOLEAN";
+ break;
+ case Column::TYPE_FLOAT:
+ $fieldDefinition[] = "'type' => Column::TYPE_FLOAT";
+ break;
+ case Column::TYPE_DOUBLE:
+ $fieldDefinition[] = "'type' => Column::TYPE_DOUBLE";
+ break;
+ case Column::TYPE_TINYBLOB:
+ $fieldDefinition[] = "'type' => Column::TYPE_TINYBLOB";
+ break;
+ case Column::TYPE_BLOB:
+ $fieldDefinition[] = "'type' => Column::TYPE_BLOB";
+ break;
+ case Column::TYPE_MEDIUMBLOB:
+ $fieldDefinition[] = "'type' => Column::TYPE_MEDIUMBLOB";
+ break;
+ case Column::TYPE_LONGBLOB:
+ $fieldDefinition[] = "'type' => Column::TYPE_LONGBLOB";
+ break;
+ case Column::TYPE_JSON:
+ $fieldDefinition[] = "'type' => Column::TYPE_JSON";
+ break;
+ case Column::TYPE_JSONB:
+ $fieldDefinition[] = "'type' => Column::TYPE_JSONB";
+ break;
+ default:
+ throw new Exception('Unrecognized data type ' . $field->getType() . ' at column ' . $field->getName());
+ }
//if ($field->isPrimary()) {
// $fieldDefinition[] = "'primary' => true";
diff --git a/scripts/Phalcon/Web/Tools.php b/scripts/Phalcon/Web/Tools.php
index ebf8156b6..89e23e675 100644
--- a/scripts/Phalcon/Web/Tools.php
+++ b/scripts/Phalcon/Web/Tools.php
@@ -373,9 +373,14 @@ public static function install($path)
throw new \Exception('Document root cannot be located');
}
- (new Bootstrap())->install($path);
- (new CodeMirror())->install($path);
- (new JQuery())->install($path);
+ $bootstrap = new Bootstrap();
+ $bootstrap->install($path);
+
+ $codeMirror = new CodeMirror();
+ $codeMirror->install($path);
+
+ $jQuery = new JQuery();
+ $jQuery->install($path);
copy($tools . '/webtools.php', $path . 'public/webtools.php');
@@ -408,9 +413,16 @@ public static function uninstall($path)
throw new \Exception('Document root cannot be located');
}
- (new Bootstrap())->uninstall($path);
- (new CodeMirror())->uninstall($path);
- (new JQuery())->uninstall($path);
+
+ $bootstrap = new Bootstrap();
+ $bootstrap->uninstall($path);
+
+ $codeMirror = new CodeMirror();
+ $codeMirror->uninstall($path);
+
+ $jQuery = new JQuery();
+ $jQuery->uninstall($path);
+
if (is_file($path . 'public/webtools.config.php')) {
unlink($path . 'public/webtools.config.php');
diff --git a/templates/project/modules/Module.php b/templates/project/modules/Module.php
index 94f1c1338..f17892c3c 100644
--- a/templates/project/modules/Module.php
+++ b/templates/project/modules/Module.php
@@ -14,9 +14,9 @@ class Module implements ModuleDefinitionInterface
/**
* Registers an autoloader related to the module
*
- * @param DiInterface $dependencyInjector
+ * @param DiInterface $di
*/
- public function registerAutoloaders(DiInterface $dependencyInjector = null)
+ public function registerAutoloaders(DiInterface $di = null)
{
$loader = new Loader();
@@ -32,9 +32,9 @@ public function registerAutoloaders(DiInterface $dependencyInjector = null)
/**
* Registers services related to the module
*
- * @param DiInterface $dependencyInjector
+ * @param DiInterface $di
*/
- public function registerServices(DiInterface $dependencyInjector)
+ public function registerServices(DiInterface $di)
{
/**
* Read configuration