PHP BeginClass函数代码示例

DefineFunction(array('name' => "__get", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__set", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant), array('name' => "value", 'type' => Variant))));
DefineFunction(array('name' => "__isset", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__unset", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "LibXMLError", 'desc' => "Contains various information about errors thrown by libxml. The error codes are described within the official » xmlError API documentation.", 'flags' => HasDocComment));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SimpleXMLElementIterator", 'desc' => "", 'flags' => HasDocComment, 'footer' => <<<EOT

public:
  void reset_iterator(c_simplexmlelement *parent);

  c_simplexmlelement *m_parent;
  ArrayIter *m_iter1;
  ArrayIter *m_iter2;
  Object     m_temp;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "current", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "key", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "next", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "rewind", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "valid", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();

// DefineProperty
//
// array (
//   'name'  => name of the property
//   'type'  => type of the property
//   'flags' => attributes of the property
//   'desc'  => description of the property
//   'note'  => additional note about this property's schema
// )
//
// EndClass()
BeginClass(array('name' => "MutableArrayIterator", 'bases' => array('Sweepable'), 'desc' => "Data structure used by the runtime to deal with mutable " . "iteration inside yield generators.", 'flags' => HasDocComment | NoDefaultSweep, 'footer' => <<<EOT

  public: union {
    char m_u[sizeof(MIterCtx)];
    TypedValue m_align;
  };
  public: bool m_valid;

  private: MIterCtx& marr() {
    return *(MIterCtx*)(m_u);
  }
EOT
));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null), 'args' => array(array('name' => "array", 'type' => Variant | Reference))));
DefineFunction(array('name' => "currentRef", 'return' => array('type' => Variant | Reference)));
DefineFunction(array('name' => "current", 'return' => array('type' => Variant)));
DefineFunction(array('name' => "key", 'return' => array('type' => Variant)));
DefineFunction(array('name' => "next", 'return' => array('type' => null)));
DefineFunction(array('name' => "valid", 'return' => array('type' => Boolean)));
EndClass();

  /**
   * Explicitly provide a t___invokeCallInfoHelper to
   * allow __invoke() to sidestep an extra level of indirection
   */
  virtual const CallInfo *t___invokeCallInfoHelper(void *&extra);

  String name() const { return String(m_name, CopyString); }

  /**
   * This is the constructor which is called internally-
   * PHP code will never be able to call this constructor
   */
  c_Closure(const CallInfo *callInfo, const char *name,
            const ObjectStaticCallbacks *cb = &cw_Closure) :
    ExtObjectData(cb), m_callInfo(callInfo), m_name(name) {
    ASSERT(callInfo);
  }
protected:
  virtual bool php_sleep(Variant &ret);
private:
  const CallInfo *m_callInfo;
  const char *m_name;
EOT
));
DefineFunction(array('name' => '__construct', 'args' => array(), 'return' => array('type' => null)));
DefineFunction(array('name' => '__invoke', 'flags' => VariableArguments, 'return' => array('type' => Variant)));
DefineFunction(array('name' => '__clone', 'return' => array('type' => Variant)));
EndClass();
BeginClass(array('name' => "DummyClosure", 'desc' => "Represents an invalid closure which will fatal when used."));
DefineFunction(array('name' => '__construct', 'args' => array(), 'return' => array('type' => null)));
EndClass();

// DefineProperty
//
// array (
//   'name'  => name of the property
//   'type'  => type of the property
//   'flags' => attributes of the property
//   'desc'  => description of the property
//   'note'  => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "Memcache", 'bases' => array('Sweepable'), 'desc' => "Represents a connection to a set of memcache servers.", 'flags' => HasDocComment, 'footer' => <<<EOT

 private:
  memcached_st m_memcache;
  int m_compress_threshold;
  double m_min_compress_savings;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "connect", 'desc' => "Memcache::connect() establishes a connection to the memcached server. The connection, which was opened using Memcache::connect() will be automatically closed at the end of script execution. Also you can close it with Memcache::close(). Also you can use memcache_connect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for connections. This parameter may also specify other transports like unix:///path/to/memcached.sock to use UNIX domain sockets, in this case port must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for connections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the daemon. Think twice before changing the default value of 1 second - you can lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "pconnect", 'desc' => "Memcache::pconnect() is similar to Memcache::connect() with the difference, that the connection it establishes is persistent. This connection is not closed after the end of script execution and by Memcache::close() function. Also you can use memcache_pconnect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for connections. This parameter may also specify other transports like unix:///path/to/memcached.sock to use UNIX domain sockets, in this case port must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for connections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the daemon. Think twice before changing the default value of 1 second - you can lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "add", 'desc' => "Memcache::add() stores variable var with key only if such key doesn't exist at the server yet. Also you can use memcache_add() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure. Returns FALSE if such key already exist. For the rest Memcache::add() behaves similarly to Memcache::set()."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as is, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses zlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the item will never expire. You can also use Unix timestamp or a number of seconds starting from current time, but in the latter case the number of seconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "set", 'desc' => "Memcache::set() stores an item var with key on the memcached server. Parameter expire is expiration time in seconds. If it's 0, the item never expires (but memcached server doesn't guarantee this item to be stored all the time, it could be deleted from the cache to make place for other items). You can use MEMCACHE_COMPRESSED constant as flag value if you want to use on-the-fly compression (uses zlib).\n\nRemember that resource variables (i.e. file and connection descriptors) cannot be stored in the cache, because they cannot be adequately represented in serialized state. Also you can use memcache_set() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as is, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses zlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the item will never expire. You can also use Unix timestamp or a number of seconds starting from current time, but in the latter case the number of seconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "replace", 'desc' => "Memcache::replace() should be used to replace value of existing item with key. In case if item with such key doesn't exists, Memcache::replace() returns FALSE. For the rest Memcache::replace() behaves similarly to Memcache::set(). Also you can use memcache_replace() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as is, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses zlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the item will never expire. You can also use Unix timestamp or a number of seconds starting from current time, but in the latter case the number of seconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "get", 'desc' => "Memcache::get() returns previously stored data if an item with such key exists on the server at this moment.\n\nYou can pass array of keys to Memcache::get() to get array of values. The result array will contain only found key-value pairs.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns the string associated with the key or FALSE on failure or if such key was not found."), 'args' => array(array('name' => "key", 'type' => Variant, 'desc' => "The key or array of keys to fetch."), array('name' => "flags", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If present, flags fetched along with the values will be written to this parameter. These flags are the same as the ones given to for example Memcache::set(). The lowest byte of the int is reserved for pecl/memcache internal usage (e.g. to indicate compression and serialization status).")), 'taint_observer' => array('set_mask' => "TAINT_BIT_ALL", 'clear_mask' => "TAINT_BIT_NONE")));
DefineFunction(array('name' => "delete", 'desc' => "Memcache::delete() deletes item with the key. If parameter timeout is specified, the item will expire after timeout seconds. Also you can use memcache_delete() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key associated with the item to delete."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Execution time of the item. If it's equal to zero, the item will be deleted right away whereas if you set it to 30, the item will be deleted in 30 seconds."))));
DefineFunction(array('name' => "increment", 'desc' => "Memcache::increment() increments value of an item by the specified value. If item specified by key was not numeric and cannot be converted to a number, it will change its value to value. Memcache::increment() does not create an item if it doesn't already exist.\n\nDo not use Memcache::increment() with items that have been stored compressed because subsequent calls to Memcache::get() will fail. Also you can use memcache_increment() function.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns new items value on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "Key of the item to increment."), array('name' => "offset", 'type' => Int32, 'value' => "1", 'desc' => "Increment the item by value."))));
DefineFunction(array('name' => "decrement", 'desc' => "Memcache::decrement() decrements value of the item by value. Similarly to Memcache::increment(), current value of the item is being converted to numerical and after that value is substracted.\n\nNew item's value will not be less than zero.\n\nDo not use Memcache::decrement() with item, which was stored compressed, because consequent call to Memcache::get() will fail. Memcache::decrement() does not create an item if it didn't exist. Also you can use memcache_decrement() function.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns item's new value on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "Key of the item do decrement."), array('name' => "offset", 'type' => Int32, 'value' => "1", 'desc' => "Decrement the item by value."))));
DefineFunction(array('name' => "getversion", 'desc' => "Memcache::getVersion() returns a string with server's version number. Also you can use memcache_get_version() function.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a string of server version number or FALSE on failure.")));
DefineFunction(array('name' => "flush", 'desc' => "Memcache::flush() immediately invalidates all existing items. Memcache::flush() doesn't actually free any resources, it only marks all the items as expired, so occupied memory will be overwritten by new items. Also you can use memcache_flush() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "expire", 'type' => Int32, 'value' => "0"))));

BeginClass(array('name' => "Memcached", 'bases' => array('Sweepable'), 'desc' => "Represents a connection to a set of memcached servers.", 'flags' => HasDocComment, 'footer' => <<<EOT

 private:
  class Impl {
  public:
    Impl();
    ~Impl();

    memcached_st memcached;
    bool compression;
    int serializer;
    int rescode;
  };
  typedef boost::shared_ptr<Impl> ImplPtr;
  ImplPtr m_impl;

  bool handleError(memcached_return status);
  void toPayload(CVarRef value, std::vector<char> &payload, uint32 &flags);
  bool toObject(Variant& value, const memcached_result_st &result);
  memcached_return doCacheCallback(CVarRef callback, CStrRef key,
                                   Variant& value);
  bool getMultiImpl(CStrRef server_key, CArrRef keys, bool enableCas,
                    Array *returnValue);
  bool fetchImpl(memcached_result_st &result, Array &item);
  typedef memcached_return_t (*SetOperation)(memcached_st *,
      const char *, size_t, const char *, size_t, const char *, size_t,
      time_t, uint32_t);
  bool setOperationImpl(SetOperation op, CStrRef server_key,
                        CStrRef key, CVarRef value, int expiration);
  typedef memcached_return_t (*IncDecOperation)(memcached_st *,
      const char *, size_t, uint32_t, uint64_t *);
  Variant incDecOperationImpl(IncDecOperation op, CStrRef key, int64 offset);

  typedef std::map<std::string, ImplPtr> ImplMap;
  static DECLARE_THREAD_LOCAL(ImplMap, s_persistentMap);
EOT
));

  public: Variant m_value;
  public: int64   m_type;
  public: String  m_stype;
  public: String  m_ns;
  public: String  m_name;
  public: String  m_namens;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "data", 'type' => Variant), array('name' => "type", 'type' => Variant), array('name' => "type_name", 'type' => String, 'value' => "null_string"), array('name' => "type_namespace", 'type' => String, 'value' => "null_string"), array('name' => "node_name", 'type' => String, 'value' => "null_string"), array('name' => "node_namespace", 'type' => String, 'value' => "null_string"))));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SoapParam", 'desc' => "Represents parameter to a SOAP call.", 'flags' => HasDocComment, 'footer' => <<<EOT

  public: String  m_name;
  public: String  m_data;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "data", 'type' => Variant), array('name' => "name", 'type' => String))));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SoapHeader", 'desc' => "Represents a SOAP header.", 'flags' => HasDocComment, 'footer' => <<<EOT

  public: String  m_namespace;
  public: String  m_name;
  public: Variant m_data;
  public: bool    m_mustUnderstand;
  public: Variant m_actor;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "ns", 'type' => String), array('name' => "name", 'type' => String), array('name' => "data", 'type' => Variant, 'value' => "null"), array('name' => "mustunderstand", 'type' => Boolean, 'value' => "false"), array('name' => "actor", 'type' => Variant, 'value' => "null"))));
EndClass();

    ),
  ));

EndClass();

BeginClass(
  array(
    'name' => 'GeneratorClosure',
    'parent' => 'Closure',
    'footer' => <<<EOT
public:
  /**
   * This is the constructor which is called internally-
   * PHP code will never be able to call this constructor
   */
  c_GeneratorClosure(
    const CallInfo *callInfo,
    void *extraData,
    CArrRef vars) :
    c_Closure(callInfo, extraData), m_vars(vars) {}
public:
  Array m_vars;    /* use variables    */
  Array m_statics; /* static variables */
EOT
,
  )
);

DefineFunction(
  array(
    'name'   => '__construct',
    'args'   => array(),

      Variant value;
    };
  public: BoundParamPtrVec m_bound_params;
EOT
));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null), 'args' => array(array('name' => "dbobject", 'type' => Object), array('name' => "statement", 'type' => String))));
DefineFunction(array('name' => "paramcount", 'desc' => "Returns the number of parameters within the prepared statement.", 'return' => array('type' => Int64, 'desc' => "Returns the number of parameters within the prepared statement.")));
DefineFunction(array('name' => "close", 'desc' => "Closes the prepared statement.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE")));
DefineFunction(array('name' => "reset", 'desc' => "Resets the prepared statement to its state prior to execution. All bindings remain intact after reset.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the statement is successfully reset, FALSE on failure.")));
DefineFunction(array('name' => "clear", 'desc' => "Clears all current bound parameters.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on successful clearing of bound parameters, FALSE on failure.")));
DefineFunction(array('name' => "bindparam", 'desc' => "Binds a parameter to a statement variable.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the parameter is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the parameter should be bound."), array('name' => "parameter", 'type' => Variant | Reference, 'desc' => "The parameter to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the parameter to bind.\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "bindvalue", 'desc' => "Binds the value of a parameter to a statement variable.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the value is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the value should be bound."), array('name' => "parameter", 'type' => Variant, 'desc' => "The value to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the value to bind.\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "execute", 'desc' => "Executes a prepared statement and returns a result set object.", 'return' => array('type' => Variant, 'desc' => "Returns an SQLite3Result object on successful execution of the prepared statement, FALSE on failure.")));
DefineFunction(array('name' => "__destruct", 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "sqlite3result", 'desc' => "A class that handles result sets for the SQLite 3 extension.", 'footer' => <<<EOT

  public: void validate() const;
  public: sp_sqlite3stmt m_stmt;
EOT
));
DefineFunction(array('name' => "__construct", 'return' => array('type' => null)));
DefineFunction(array('name' => "numcolumns", 'desc' => "Returns the number of columns in the result set.", 'return' => array('type' => Int64, 'desc' => "Returns the number of columns in the result set.")));
DefineFunction(array('name' => "columnname", 'desc' => "Returns the name of the column specified by the column_number.", 'return' => array('type' => String, 'desc' => "Returns the string name of the column identified by column_number."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "columntype", 'desc' => "Returns the type of the column identified by column_number.", 'return' => array('type' => Int64, 'desc' => "Returns the data type index of the column identified by column_number (one of SQLITE3_INTEGER, SQLITE3_FLOAT, SQLITE3_TEXT, SQLITE3_BLOB, or SQLITE3_NULL)."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "fetcharray", 'desc' => "Fetches a result row as an associative or numerically indexed array or both. By default, fetches as both.", 'return' => array('type' => Variant, 'desc' => "Returns a result row as an associatively or numerically indexed array or both."), 'args' => array(array('name' => "mode", 'type' => Int64, 'value' => "k_SQLITE3_BOTH", 'desc' => "Controls how the next row will be returned to the caller. This value must be one of either SQLITE3_ASSOC, SQLITE3_NUM, or SQLITE3_BOTH.\nSQLITE3_ASSOC: returns an array indexed by column name as returned in the corresponding result set\nSQLITE3_NUM: returns an array indexed by column number as returned in the corresponding result set, starting at column 0\nSQLITE3_BOTH: returns an array indexed by both column name and number as returned in the corresponding result set, starting at column 0"))));
DefineFunction(array('name' => "reset", 'return' => array('type' => Boolean)));
DefineFunction(array('name' => "finalize", 'desc' => "Closes the result set.", 'return' => array('type' => Boolean, 'desc' => "Returns TRUE.")));
DefineFunction(array('name' => "__destruct", 'return' => array('type' => Variant)));
EndClass();

//   'desc'  => description of the property
//   'note'  => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "EncodingDetector", 'desc' => "Guesses the encoding of an array of bytes in an unknown encoding (see http://icu-project.org/apiref/icu4c/ucsdet_8h.html)", 'flags' => HasDocComment, 'footer' => <<<EOT

  private: UCharsetDetector *m_encoding_detector;
EOT
));
DefineFunction(array('name' => "__construct", 'desc' => "Creates an encoding detector.", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "setText", 'desc' => "Sets the input byte array whose encoding is to be guessed.", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "text", 'type' => String, 'desc' => "A byte array whose encoding is to be guessed."))));
DefineFunction(array('name' => "setDeclaredEncoding", 'desc' => "If the user provided an encoding in metadata (like an HTTP or XML declaration), this can be used as an additional hint to the detector.", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "text", 'type' => String, 'desc' => "Possible encoding for the byte array obtained from associated metadata"))));
DefineFunction(array('name' => "detect", 'desc' => "Returns an EncodingMatch object containing the best guess for the encoding of the byte array", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "EncodingMatch object for the best guess of the encoding of the byte array")));
DefineFunction(array('name' => "detectAll", 'desc' => "Returns an array of EncodingMatch objects containing all guesses for the encoding of the byte array", 'flags' => HasDocComment, 'return' => array('type' => VariantVec, 'desc' => "Array of EncodingMatch objects for all guesses of the encoding of the byte array")));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "EncodingMatch", 'desc' => "Result of detecting the encoding of an array of bytes", 'flags' => HasDocComment, 'footer' => <<<EOT

  public: const UCharsetMatch *m_encoding_match;
  private: void validate();
EOT
));
DefineFunction(array('name' => "__construct", 'desc' => "Internal only: Creates an encoding match.", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "isValid", 'desc' => "Checks if the encoding match succeeded.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "true if the match succeeded, false otherwise")));
DefineFunction(array('name' => "getEncoding", 'desc' => "Gets the name of the detected encoding", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The name of the detected encoding")));
DefineFunction(array('name' => "getConfidence", 'desc' => "Gets the confidence number of the encoding match", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Confidence number from 0 (no confidence) to 100 (complete confidence)")));
DefineFunction(array('name' => "getLanguage", 'desc' => "Gets a rough guess at the language of the encoded bytes", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "A rough guess at the language of the encoded bytes")));
DefineFunction(array('name' => "getUTF8", 'desc' => "Gets the UTF-8 encoded version of the encoded byte array", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The result of converting the bytes to UTF-8 with the detected encoding")));
EndClass();

      Variant value;
    };
  public: BoundParamPtrVec m_bound_params;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "dbobject", 'type' => Object), array('name' => "statement", 'type' => String))));
DefineFunction(array('name' => "paramcount", 'desc' => "Returns the number of parameters within the prepared statement.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the number of parameters within the prepared statement.")));
DefineFunction(array('name' => "close", 'desc' => "Closes the prepared statement.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE")));
DefineFunction(array('name' => "reset", 'desc' => "Resets the prepared statement to its state prior to execution. All bindings remain intact after reset.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the statement is successfully reset, FALSE on failure.")));
DefineFunction(array('name' => "clear", 'desc' => "Clears all current bound parameters.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on successful clearing of bound parameters, FALSE on failure.")));
DefineFunction(array('name' => "bindparam", 'desc' => "Binds a parameter to a statement variable.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the parameter is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the parameter should be bound."), array('name' => "parameter", 'type' => Variant | Reference, 'desc' => "The parameter to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the parameter to bind.\n\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\n\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\n\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\n\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\n\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "bindvalue", 'desc' => "Binds the value of a parameter to a statement variable.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE if the value is bound to the statement variable, FALSE on failure."), 'args' => array(array('name' => "name", 'type' => Variant, 'desc' => "An string identifying the statement variable to which the value should be bound."), array('name' => "parameter", 'type' => Variant, 'desc' => "The value to bind to a statement variable."), array('name' => "type", 'type' => Int64, 'value' => "k_SQLITE3_TEXT", 'desc' => "The data type of the value to bind.\n\nSQLITE3_INTEGER: The value is a signed integer, stored in 1, 2, 3, 4, 6, or 8 bytes depending on the magnitude of the value.\n\nSQLITE3_FLOAT: The value is a floating point value, stored as an 8-byte IEEE floating point number.\n\nSQLITE3_TEXT: The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16-LE).\n\nSQLITE3_BLOB: The value is a blob of data, stored exactly as it was input.\n\nSQLITE3_NULL: The value is a NULL value."))));
DefineFunction(array('name' => "execute", 'desc' => "Executes a prepared statement and returns a result set object.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns an SQLite3Result object on successful execution of the prepared statement, FALSE on failure.")));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "SQLite3Result", 'desc' => "A class that handles result sets for the SQLite 3 extension.", 'flags' => HasDocComment, 'footer' => <<<EOT

  public: void validate() const;
  public: p_SQLite3Stmt m_stmt;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "numcolumns", 'desc' => "Returns the number of columns in the result set.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the number of columns in the result set.")));
DefineFunction(array('name' => "columnname", 'desc' => "Returns the name of the column specified by the column_number.", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "Returns the string name of the column identified by column_number."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "columntype", 'desc' => "Returns the type of the column identified by column_number.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns the data type index of the column identified by column_number (one of SQLITE3_INTEGER, SQLITE3_FLOAT, SQLITE3_TEXT, SQLITE3_BLOB, or SQLITE3_NULL)."), 'args' => array(array('name' => "column", 'type' => Int64, 'desc' => "The numeric zero-based index of the column."))));
DefineFunction(array('name' => "fetcharray", 'desc' => "Fetches a result row as an associative or numerically indexed array or both. By default, fetches as both.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a result row as an associatively or numerically indexed array or both."), 'args' => array(array('name' => "mode", 'type' => Int64, 'value' => "k_SQLITE3_BOTH", 'desc' => "Controls how the next row will be returned to the caller. This value must be one of either SQLITE3_ASSOC, SQLITE3_NUM, or SQLITE3_BOTH.\n\nSQLITE3_ASSOC: returns an array indexed by column name as returned in the corresponding result set\n\nSQLITE3_NUM: returns an array indexed by column number as returned in the corresponding result set, starting at column 0\n\nSQLITE3_BOTH: returns an array indexed by both column name and number as returned in the corresponding result set, starting at column 0"))));
DefineFunction(array('name' => "reset", 'flags' => HasDocComment, 'return' => array('type' => Boolean)));
DefineFunction(array('name' => "finalize", 'desc' => "Closes the result set.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE.")));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();

//
// array (
//   'name'  => name of the property
//   'type'  => type of the property
//   'flags' => attributes of the property
//   'desc'  => description of the property
//   'note'  => additional note about this property's schema
// )
//
// EndClass()
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "MemcachePool", 'bases' => array('Sweepable'), 'desc' => "Represents a connection to a set of memcache servers.", 'flags' => HasDocComment, 'footer' => <<<EOT
  public: void close();
  private: 
    bool prefetch(CVarRef key);
    bool check_memcache_return(memcached_st * st, memcached_return_t ret, 
                               String key = "", char *default_msg = "");
    void exec_failure_callback(const char * hostname, int tcp_port, int udp_port,
                               memcached_return_t ret, const char * error, Array backtrace);
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "getstoragememcache", 'desc' => "MemcachePool::getstoragememcache() is a static member to get\n\t\tonly one instance per storage_id and thread. The timestamp is used to know\n\t\tif the stored object have old configuration and need to be recreated", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => Object, 'desc' => "Returns a MemcachePool Object or NULL if we need to create\n\t\t\tnew one (next call will return a new Object)."), 'args' => array(array('name' => "storage_id", 'type' => Int32, 'desc' => "Number of the storage id (used to get only one instance per\n\t\t\t\tstorage)."), array('name' => "timestamp", 'type' => Int32, 'desc' => "Time of the last configuration change."), array('name' => "empty", 'type' => Variant | Reference, 'desc' => "This parameter is needed to indicate if the memcached\n\t\t\t\tobject is new and needs to be populated with the memcached servers"), array('name' => "persistent", 'type' => Boolean, 'value' => "false", 'desc' => "Defines if the tcp connections should be persistent"))));
DefineFunction(array('name' => "connect", 'desc' => "MemcachePool::connect() establishes a connection to the memcached\n\t\tserver. The connection, which was opened using MemcachePool::connect() will be\n\t\tautomatically closed at the end of script execution. Also you can close it\n\t\twith MemcachePool::close(). Also you can use memcache_connect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for\n\t\t\t\tconnections. This parameter may also specify other transports like\n\t\t\t\tunix:///path/to/memcached.sock to use UNIX domain sockets, in this case\n\t\t\t\tport must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for\n\t\t\t\tconnections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the\n\t\t\t\tdaemon. Think twice before changing the default value of 1 second - you\n\t\t\t\tcan lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "pconnect", 'desc' => "MemcachePool::pconnect() is similar to MemcachePool::connect() with the\n\t\tdifference, that the connection it establishes is persistent. This\n\t\tconnection is not closed after the end of script execution and by\n\t\tMemcachePool::close() function. Also you can use memcache_pconnect() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "host", 'type' => String, 'desc' => "Point to the host where memcached is listening for\n\t\t\t\tconnections. This parameter may also specify other transports like\n\t\t\t\tunix:///path/to/memcached.sock to use UNIX domain sockets, in this case\n\t\t\t\tport must also be set to 0."), array('name' => "port", 'type' => Int32, 'value' => "0", 'desc' => "Point to the port where memcached is listening for\n\t\t\t\tconnections. Set this parameter to 0 when using UNIX domain sockets."), array('name' => "timeout", 'type' => Int32, 'value' => "0", 'desc' => "Value in seconds which will be used for connecting to the\n\t\t\t\tdaemon. Think twice before changing the default value of 1 second - you\n\t\t\t\tcan lose all the advantages of caching if your connection is too slow."), array('name' => "timeoutms", 'type' => Int32, 'value' => "0"))));
DefineFunction(array('name' => "add", 'desc' => "MemcachePool::add() stores variable var with key only if such key\n\t\tdoesn't exist at the server yet. Also you can use memcache_add() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure. Returns FALSE if\n\t\t\tsuch key already exist. For the rest MemcachePool::add() behaves similarly to\n\t\t\tMemcachePool::set()."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "cas", 'desc' => "MemcachePool::cas() have the same behaviour as set, but only\n\t\tchanges the item if its was unchanged from the last time the value was\n\t\tobtained. This is checked using CAS parameter, obtained when calling get", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."), array('name' => "cas_token", 'type' => Double, 'desc' => "Unique value associated with the existing item. Generated\n\t\t\t\tby memcache."))));
DefineFunction(array('name' => "set", 'desc' => "MemcachePool::set() stores an item var with key on the memcached\n\t\tserver. Parameter expire is expiration time in seconds. If it's 0, the item\n\t\tnever expires (but memcached server doesn't guarantee this item to be stored\n\t\tall the time, it could be deleted from the cache to make place for other\n\t\titems). You can use MEMCACHE_COMPRESSED constant as flag value if you want\n\t\tto use on-the-fly compression (uses zlib).\n\nRemember that resource\n\t\tvariables (i.e. file and connection descriptors) cannot be stored in the\n\t\tcache, because they cannot be adequately represented in serialized state.\n\t\tAlso you can use memcache_set() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "replace", 'desc' => "MemcachePool::replace() should be used to replace value of existing\n\t\titem with key. In case if item with such key doesn't exists,\n\t\tMemcachePool::replace() returns FALSE. For the rest MemcachePool::replace() behaves\n\t\tsimilarly to MemcachePool::set(). Also you can use memcache_replace()\n\t\tfunction.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key that will be associated with the item."), array('name' => "var", 'type' => Variant, 'desc' => "The variable to store. Strings and integers are stored as\n\t\t\t\tis, other types are stored serialized."), array('name' => "flag", 'type' => Int32, 'value' => "0", 'desc' => "Use MEMCACHE_COMPRESSED to store the item compressed (uses\n\t\t\t\tzlib)."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Expiration time of the item. If it's equal to zero, the\n\t\t\t\titem will never expire. You can also use Unix timestamp or a number of\n\t\t\t\tseconds starting from current time, but in the latter case the number of\n\t\t\t\tseconds may not exceed 2592000 (30 days)."))));
DefineFunction(array('name' => "get", 'desc' => "MemcachePool::get() returns previously stored data if an item with\n\t\tsuch key exists on the server at this moment.\n\nYou can pass array of keys\n\t\tto MemcachePool::get() to get array of values. The result array will contain\n\t\tonly found key-value pairs.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns the string associated with the key or FALSE on\n\t\t\tfailure or if such key was not found."), 'args' => array(array('name' => "key", 'type' => Variant, 'desc' => "The key or array of keys to fetch."), array('name' => "flags", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If present, flags fetched along with the values will be\n\t\t\t\twritten to this parameter. These flags are the same as the ones given to\n\t\t\t\tfor example MemcachePool::set(). The lowest byte of the int is reserved for\n\t\t\t\tpecl/memcache internal usage (e.g. to indicate compression and\n\t\t\t\tserialization status)."), array('name' => "cas", 'type' => Variant | Reference, 'value' => "null", 'desc' => "If present, cas key wil be fetched along with the values\n\t\t\t\tand will be written to this parameter."))));
DefineFunction(array('name' => "prefetch", 'desc' => "MemcachePool::prefetch() prefetch some keys, without actual\n\t\treturning the values of those keys. You need to call later to get, in order\n\t\tto fetch the results.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => Variant, 'desc' => "The key or array of keys to fetch."))));
DefineFunction(array('name' => "delete", 'desc' => "MemcachePool::delete() deletes item with the key. If parameter\n\t\ttimeout is specified, the item will expire after timeout seconds. Also you\n\t\tcan use memcache_delete() function.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "key", 'type' => String, 'desc' => "The key associated with the item to delete."), array('name' => "expire", 'type' => Int32, 'value' => "0", 'desc' => "Execution time of the item. If it's equal to zero, the item\n\t\t\t\twill be deleted right away whereas if you set it to 30, the item will be\n\t\t\t\tdeleted in 30 seconds."))));

DefineFunction(array('name' => 'key', 'return' => array('type' => Int64)));
DefineFunction(array('name' => 'next', 'return' => array('type' => null)));
DefineFunction(array('name' => 'rewind', 'return' => array('type' => null)));
DefineFunction(array('name' => 'valid', 'return' => array('type' => Boolean)));
DefineFunction(array('name' => 'send', 'return' => array('type' => null), 'args' => array(array('name' => 'v', 'type' => Variant))));
DefineFunction(array('name' => 'raise', 'return' => array('type' => null), 'args' => array(array('name' => 'v', 'type' => Variant))));
DefineFunction(array('name' => 'raised', 'return' => array('type' => null)));
DefineFunction(array('name' => 'receive', 'return' => array('type' => Variant)));
DefineFunction(array('name' => 'getOrigFuncName', 'return' => array('type' => String)));
DefineProperty(array('name' => 'obj', 'type' => Object, 'flags' => IsPrivate));
DefineProperty(array('name' => 'args', 'type' => VariantVec, 'flags' => IsPrivate));
DefineProperty(array('name' => 'label', 'type' => Int64, 'flags' => IsPrivate));
DefineProperty(array('name' => 'index', 'type' => Int64, 'flags' => IsPrivate));
DefineProperty(array('name' => 'value', 'type' => Variant, 'flags' => IsPrivate));
DefineProperty(array('name' => 'received', 'type' => Variant, 'flags' => IsPrivate));
DefineProperty(array('name' => 'origFuncName', 'type' => String, 'flags' => IsPrivate));
DefineProperty(array('name' => 'called_class', 'type' => String, 'flags' => IsPrivate));
DefineProperty(array('name' => 'done', 'type' => Boolean, 'flags' => IsPrivate));
DefineProperty(array('name' => 'running', 'type' => Boolean, 'flags' => IsPrivate));
DefineFunction(array('name' => '__clone', 'return' => array('type' => Variant)));
EndClass();
BeginClass(array('name' => 'GenericContinuation', 'parent' => 'Continuation', 'footer' => <<<EOT
public:
  LVariableTable m_statics;
EOT
));
DefineFunction(array('name' => '__construct', 'return' => array('type' => null), 'args' => array(array('name' => 'func', 'type' => Int64), array('name' => 'extra', 'type' => Int64), array('name' => 'isMethod', 'type' => Boolean), array('name' => 'origFuncName', 'type' => String), array('name' => 'vars', 'type' => VariantMap), array('name' => 'obj', 'type' => Variant, 'value' => 'null'), array('name' => 'args', 'type' => VariantMap, 'value' => 'null_array'))));
DefineFunction(array('name' => 'update', 'return' => array('type' => null), 'args' => array(array('name' => 'label', 'type' => Int64), array('name' => 'value', 'type' => Variant), array('name' => 'vars', 'type' => VariantMap))));
DefineFunction(array('name' => 'getVars', 'return' => array('type' => VariantMap)));
DefineProperty(array('name' => 'vars', 'type' => VariantMap, 'flags' => IsPrivate));
EndClass();

DefineFunction(array('name' => "getOffset", 'desc' => "Procedural style int timezone_offset_get ( DateTimeZone \$object , DateTime \$datetime ) This function returns the offset to GMT for the date/time specified in the datetime parameter. The GMT offset is calculated with the timezone information contained in the DateTimeZone object being used.", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "Returns time zone offset in seconds on success or FALSE on failure."), 'args' => array(array('name' => "datetime", 'type' => Object, 'desc' => "DateTimeZone object returned by timezone_open()"))));
DefineFunction(array('name' => "getTransitions", 'desc' => "Procedural style array timezone_transitions_get ( DateTimeZone \$object [, int \$timestamp_begin [, int \$timestamp_end ]] )", 'flags' => HasDocComment, 'return' => array('type' => VariantMap, 'desc' => "Returns numerically indexed array containing associative array with all transitions on success or FALSE on failure.")));
DefineFunction(array('name' => "listAbbreviations", 'desc' => "Procedural style array timezone_abbreviations_list ( void )", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => VariantMap, 'desc' => "Returns array on success or FALSE on failure.")));
DefineFunction(array('name' => "listIdentifiers", 'desc' => "Procedural style array timezone_identifiers_list ([ int \$what = DateTimeZone::ALL [, string \$country = NULL ]] )", 'flags' => IsStatic | HasDocComment, 'return' => array('type' => VariantMap, 'desc' => "Returns array on success or FALSE on failure.")));
EndClass();
BeginClass(array('name' => "DateInterval", 'desc' => "Represents a date interval.", 'flags' => HasDocComment, 'footer' => <<<EOT

  public: static Object wrap(SmartObject<DateInterval> di) {
    c_DateInterval *cdi = NEWOBJ(c_DateInterval)();
    Object ret(cdi);
    cdi->m_di = di;
    return ret;
  }

  public: static SmartObject<DateInterval> unwrap(CObjRef dateinterval) {
    SmartObject<c_DateInterval> cdi = dateinterval.getTyped<c_DateInterval>(true);
    if (cdi.get() == NULL)
      return SmartObject<DateInterval>();
    return cdi->m_di;
  }

 private:
  SmartObject<DateInterval> m_di;
 public:
  virtual ObjectData *clone();
EOT
));
# Object Psuedo-Properties - Implemented with __get()/__set()
# since underlying rel time must adjust automatically when set
#
# y - Number of years
# m - Number of months

// )
BeginClass(array('name' => 'GmagickPixel', 'bases' => array('Sweepable'), 'desc' => 'Gmagick pixel class', 'flags' => HasDocComment, 'footer' => <<<EOT
   public: 
     PixelWand *get_PixelWand();
   private:
     PixelWand *pixel_wand;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "color", 'type' => String, 'value' => "null_string"))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
BeginClass(array('name' => 'Gmagick', 'bases' => array('Sweepable'), 'desc' => 'Gmagick main class', 'flags' => HasDocComment, 'footer' => <<<EOT
 private:
  void checkResult(int result);
  void checkNotEmpty(); 
  void checkHasFormat();
  void throwException(const char * magick_message, int magick_severity);
  bool adjust_dimensions(bool bestfit, long desired_width, long desired_height, long *new_width, long *new_height);
  MagickWand *magick_wand;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
DefineFunction(array('name' => "destroy", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "getcopyright", 'flags' => HasDocComment, 'return' => array('type' => String)));
DefineFunction(array('name' => "readimageblob", 'flags' => HasDocComment, 'return' => array('type' => Object, 'desc' => "The Gmagick object itself (for method chaining)."), 'args' => array(array('name' => "blob", 'type' => String), array('name' => "filename", 'type' => String))));
DefineFunction(array('name' => "getimageblob", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The image blob")));
DefineFunction(array('name' => "getimagefilename", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The filename of a particular image in a sequence")));
DefineFunction(array('name' => "getimagetype", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "The potential image type")));
DefineFunction(array('name' => "getimageformat", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The format of a particular image in a sequence")));
DefineFunction(array('name' => "getimagecolorspace", 'flags' => HasDocComment, 'return' => array('type' => Int64, 'desc' => "The color space of a particular image in a sequence")));
DefineFunction(array('name' => "getimageprofile", 'flags' => HasDocComment, 'return' => array('type' => String, 'desc' => "The named image profile"), 'args' => array(array('name' => "profile", 'type' => String))));

DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DOMImplementation", 'desc' => "The DOMImplementation interface provides a number of methods for performing operations that are independent of any particular instance of the document object model.", 'flags' => HasDocComment));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null)));
DefineFunction(array('name' => "createDocument", 'desc' => "Creates a DOMDocument object of the specified type with its document element.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "A new DOMDocument object. If namespaceURI, qualifiedName, and doctype are null, the returned DOMDocument is empty with no document element"), 'args' => array(array('name' => "namespaceuri", 'type' => String, 'value' => "null_string", 'desc' => "The namespace URI of the document element to create."), array('name' => "qualifiedname", 'type' => String, 'value' => "null_string", 'desc' => "The qualified name of the document element to create."), array('name' => "doctypeobj", 'type' => Object, 'value' => "null_object", 'desc' => "The type of document to create or NULL."))));
DefineFunction(array('name' => "createDocumentType", 'desc' => "Creates an empty DOMDocumentType object. Entity declarations and notations are not made available. Entity reference expansions and default attribute additions do not occur.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "A new DOMDocumentType node with its ownerDocument set to NULL."), 'args' => array(array('name' => "qualifiedname", 'type' => String, 'value' => "null_string", 'desc' => "The qualified name of the document type to create."), array('name' => "publicid", 'type' => String, 'value' => "null_string", 'desc' => "The external subset public identifier."), array('name' => "systemid", 'type' => String, 'value' => "null_string", 'desc' => "The external subset system identifier."))));
DefineFunction(array('name' => "hasFeature", 'desc' => "Test if the DOM implementation implements a specific feature.\n\nYou can find a list of all features in the » Conformance section of the DOM specification.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "feature", 'type' => String, 'desc' => "The feature to test."), array('name' => "version", 'type' => String, 'desc' => "The version number of the feature to test. In level 2, this can be either 2.0 or 1.0."))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();
///////////////////////////////////////////////////////////////////////////////
BeginClass(array('name' => "DOMXPath", 'bases' => array('Sweepable'), 'desc' => "Supports XPath 1.0", 'flags' => HasDocComment | NoDefaultSweep, 'footer' => <<<EOT

 public:
  xmlNodePtr m_node;
  p_DOMDocument m_doc;
  Array m_node_list;
  int m_registerPhpFunctions;
  Array m_registered_phpfunctions;
EOT
));
DefineFunction(array('name' => "__construct", 'flags' => HasDocComment, 'return' => array('type' => null), 'args' => array(array('name' => "doc", 'type' => Variant))));
DefineFunction(array('name' => "evaluate", 'desc' => "Executes the given XPath expression and returns a typed result if possible.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a typed result if possible or a DOMNodeList containing all nodes matching the given XPath expression."), 'args' => array(array('name' => "expr", 'type' => String, 'desc' => "The XPath expression to execute."), array('name' => "context", 'type' => Object, 'value' => "null_object", 'desc' => "The optional contextnode can be specified for doing relative XPath queries. By default, the queries are relative to the root element."))));
DefineFunction(array('name' => "query", 'desc' => "Executes the given XPath expression.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "Returns a DOMNodeList containing all nodes matching the given XPath expression. Any expression which do not return nodes will return an empty DOMNodeList."), 'args' => array(array('name' => "expr", 'type' => String, 'desc' => "The XPath expression to execute."), array('name' => "context", 'type' => Object, 'value' => "null_object", 'desc' => "The optional contextnode can be specified for doing relative XPath queries. By default, the queries are relative to the root element."))));
DefineFunction(array('name' => "registerNamespace", 'desc' => "Registers the namespaceURI and prefix with the DOMXPath object.", 'flags' => HasDocComment, 'return' => array('type' => Boolean, 'desc' => "Returns TRUE on success or FALSE on failure."), 'args' => array(array('name' => "prefix", 'type' => String, 'desc' => "The prefix."), array('name' => "uri", 'type' => String, 'desc' => "The URI of the namespace."))));
DefineFunction(array('name' => "registerPHPFunctions", 'desc' => "This method enables the ability to use PHP functions within XPath expressions.", 'flags' => HasDocComment, 'return' => array('type' => Variant, 'desc' => "No value is returned."), 'args' => array(array('name' => "funcs", 'type' => Variant, 'value' => "null", 'desc' => "Use this parameter to only allow certain functions to be called from XPath.\n\nThis parameter can be either a string (a function name) or an array of function names."))));
DefineFunction(array('name' => "__get", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__set", 'flags' => HasDocComment, 'return' => array('type' => Variant), 'args' => array(array('name' => "name", 'type' => Variant), array('name' => "value", 'type' => Variant))));
DefineFunction(array('name' => "__isset", 'flags' => HasDocComment, 'return' => array('type' => Boolean), 'args' => array(array('name' => "name", 'type' => Variant))));
DefineFunction(array('name' => "__destruct", 'flags' => HasDocComment, 'return' => array('type' => Variant)));
EndClass();