Fetches the next row and returns it as an object.

@param	string	$class_name - Name of the created class.
@param	array	$ctor_class - Elements of this array are passed to the constructor.
@return	object
425620
public function fetchObject($class_name = NULL, array $ctor_class = array())
	{
		if($this->executed == true)
		{
			if(!$this->resource)
			{
				return false;
			}
			elseif($this->isFetchAll == true)
			{
				throw new LikePDOStatement("There is no active statement");
				return false;
			}
		}
		else
		{
			throw new LikePDOStatement("There is no active statement");
			return false;
		}
		
		$fetch = $this->pdo->driver->fetch($this->resource, LikePDO::FETCH_OBJ);
		
		if($class_name)
		{
			if(!class_exists($class_name))
			{
				throw new LikePDOException("Class '".$class_name."' not found");
				return false;
			}
			else
			{
				if(!is_array($ctor_class))
				{
					throw new LikePDOException("Warning: LikePDOStatement::fetchObject() expects parameter 2 to be array, ".gettype($ctor_class)." given");
					return false;
				}
				
				$instance = new ReflectionClass($class_name);
				$foo = $instance->newInstanceArgs($ctor_class);
				
				if(count($fetch) > 0)
				{
					foreach($fetch as $key => $value)
					{
						$key = $this->realColumnAttribute($key);
						$foo->{$key} = $value;
					}
				}
				
				unset($fetch);
				return $foo;
			}
		}
		else
		{
			$return = new stdClass();
			
			if(count($fetch) > 0)
			{
				foreach($fetch as $key => $value)
				{
					$key = $this->realColumnAttribute($key);
					$return->{$key} = $value;
				}
			}
			
			unset($fetch);
			return $return;
		}		
	}
1075601
public function findContentsByClassname($classnameArr = array(), $orderInfos = array(), $limitInfos = array())
    {
        $result = array();
        if (!is_array($classnameArr)) {
            return $result;
        }
        $db = $this->_em->getConnection();

        $start = (is_array($limitInfos) && array_key_exists('start', $limitInfos)) ? (int) $limitInfos['start'] : 0;
        $limit = (is_array($limitInfos) && array_key_exists('limit', $limitInfos)) ? (int) $limitInfos['limit'] : 0;
        $stmt = $db->executeQuery('SELECT * FROM `content` WHERE `classname` IN (?) order by modified desc limit ?,?', array($classnameArr, $start, $limit), array(\Doctrine\DBAL\Connection::PARAM_STR_ARRAY, 1, 1)
        );

        $items = $stmt->fetchAll();
        if ($items) {
            foreach ($items as $item) {
                $content = $this->_em->find(AbstractClassContent::getFullClassname($item['classname']), $item['uid']);
                if ($content) {
                    $result[] = $content;
                }
            }
        }

        return $result;
    }
937545
public function getLastNameSpace($class_name)
    {
        $class          = new \ReflectionClass($class_name);
        //获取命名空间
        $namespace      = $class->getNamespaceName();
        //分割获取命名空间
        $arr_namespace  = $namespace ? explode('\\', $namespace):array("");
        //获取最后一个命名空间
        $end_namespace  = array_pop($arr_namespace);
        return $end_namespace;
    }
862708
private function constructor(string $class_name, array $params = null)
    {
        $this->state->category = CompilerState::CATEGORY_CONSTRUCTOR;
        $this->state->name = '';
        $params_str = '';
        if (is_array($params)){
            $params_str = $this->decorateParamsForMethodCall($params);
        }
        return $class_name . '(' . $params_str . ')';
    }
165045
public function getFirstNameSpace($class_name)
    {
        $class          = new \ReflectionClass($class_name);
        //获取命名空间
        $namespace      = $class->getNamespaceName();
        //分割获取命名空间
        $arr_namespace  = $namespace ? explode('\\', $namespace) : array("");
        //获取第一命名空间
        $first_namespace= array_shift($arr_namespace);
        return $first_namespace;
    }
120724
public static function GetClassVar ($name, $default_value = null) {
		if (is_array($name)) {
			return Arrays::GetLowest(static::$_ClassVariableTrait_Data, $name) ?: $default_value;
		}
		return isset(static::$_ClassVariableTrait_Data[$name]) ? static::$_ClassVariableTrait_Data[$name] : $default_value;
	}
1176882
public function getNamespace($class_name)
	{
		$class_name = trim($class_name, '\\');
		if ($last_separator = strrpos($class_name, '\\'))
		{
			return substr($class_name, 0, $last_separator + 1);
		}
		return '';
	}
122110
public function getOr( $name, $default_value )
	{
		if ($this->offsetExists($name))
		{
			return $this->items[$name];
		}
		return Helper::value($default_value);
	}
983340
def class_name(name, separator = '::', want_array = false)
    Manager.connection.class_name(name, separator, want_array)
  end
514183
def next_header_class(self):
        ''''''
        if self._next_header_class_key == '':
            return None
        key = getattr(self, self._next_header_class_key)
        rv = self._next_header_map.get(key, None)
        if rv is None:
            log_warn("No class exists to handle next header value {}".format(key))
        return rv
1098929
public function fetchObject(string $className = "stdClass", array $ctorArgs = null)
    {
        $object = BeanFactory::newInstance($className);
        foreach($this->fetch(\PDO::FETCH_ASSOC) as $name => $value)
        {
            $object->$name = $value;
        }
        return $object;
    }
1020225
public function fetchObject($name='stdClass', $ctor_args=null)
    {
        try {
            $data = $this->fetch(\PDO::FETCH_ASSOC);
            return $this->_createObjectFromData($name, $data);
        } catch (\Exception $e) {
            return null;
        }
    }
844214
protected function getNextRow()
    {
        # If the result resource is invalid then don't bother trying to fetch
        if (!$this->result) {
            return;
        }

        switch ($this->mode) {

            case "mysql":
                $row = $this->result->fetch_assoc();
                break;

            case "postgres":
            case "redshift":
                $row = pg_fetch_assoc($this->result);
                break;

            case "odbc":
                $row = odbc_fetch_array($this->result, $this->position + 1);
                break;

            case "sqlite":
                $row = $this->result->fetchArray(SQLITE3_ASSOC);
                break;

            case "mssql":
                $row = mssql_fetch_assoc($this->result);
                break;

            case "mssqlsrv":
                sqlsrv_fetch($this->result, SQLSRV_SCROLL_ABSOLUTE, $this->position);
                $row = sqlsrv_fetch_array($this->result, SQLSRV_FETCH_ASSOC);

                if ($row) {
                    foreach ($row as &$value) {
                        if ($value instanceof \DateTime) {
                            $value = $value->format(\DateTime::ISO8601);
                        }
                    }
                }
                unset($value);
                break;
        }

        # If the fetch fails then there are no rows left to retrieve
        if (!$row) {
            return;
        }

        $this->position++;

        return $row;
    }
244804
function get_object($sql, $class_name = 'stdClass', array $params = null)
	{
		$rs = $this->query($sql, MYSQLI_USE_RESULT);
		$obj = is_null($params) ? $rs->fetch_object($class_name) : $rs->fetch_object($class_name, $params);
		$rs->free_result();
		return $obj;
	}
946483
protected function childrenByInstance($class_name) {
    $matches = [];
    $child = $this->head;
    while ($child) {
      if ($child instanceof $class_name) {
        $matches[] = $child;
      }
      $child = $child->next;
    }
    return $matches;
  }
462895
public function get_class_vars( $class_name, $var ) {
		$class          = Singleton::get_instance( $class_name, $this );
		$reflection_obj = new \ReflectionObject( $class );
		if ( ! $reflection_obj->hasProperty( $var ) ) {
			return false;
		}
		$property = $reflection_obj->getProperty( $var );
		$property->setAccessible( true );

		return $property->getValue( $class );
	}
235596
public function next(){

		if(next($this->_fetched) instanceof SQLResultRow){

			return current($this->_fetched);
		}
		else{

			try{

				$mySQLResultRow = new MySQLResultRow($this->_result);
			}
			catch(SQLResultRowException $e){

				return false;
			}

			// Clear fetch buffer in case of an unbuffered result-set

			if(!$this->_buffered){

				$this->_fetched = [];
			}

			$this->_fetched[] = $mySQLResultRow;

			return $mySQLResultRow;
		}
	}