Decides whether there is a custom method on the class for the specified column. Returns method name if yes.

@param string Name of the column

@return bool|string
777821
protected function customisesColumnValue($columnName)
    {
        $methodName = camel_case('laratables_'.$columnName);

        if (method_exists($this->class, $methodName)) {
            return $methodName;
        }

        return false;
    }
752880
public function hasColumn($name)
    {
        $name = $this->filterInputColumn($name);

        return in_array($name, $this->getFields());
    }
639274
public static function name(string $name) : ColumnLabelBuilder
    {
        $self       = new self();
        $self->name = $name;

        return new ColumnLabelBuilder($self);
    }
16237
protected function getMethod($name) 
    {
        if (isset(self::$_methods[$name])) {
            return $name;
        }

        if (isset(self::$_methods['array_'.$name])) {
            return 'array_'.$name;
        }

        $uncamel = strtolower(preg_replace("/([A-Z])/", "_$1", $name));

        if (isset(self::$_methods[$uncamel])) {
            return $uncamel;
        }

        if (isset(self::$_methods['array_'.$uncamel])) {
            return 'array_'.$uncamel;
        }

        return $name;
    }
710259
public function isArgument($name) {
        if (!is_string($name)) throw new IllegalTypeException('Illegal type of parameter $name: '.gettype($name));
        if (!$this->docoptResult)
            return false;

        if (!($len=strlen($name)) || !isset($this->docoptResult[$name]))
            return false;

        $isBracketed = ('<'==$name[0] && $name[$len-1]=='>');
        $isUpperCase = ($name == strtoupper($name));

        return ($isBracketed || $isUpperCase);
    }
665047
public static Method findMethod (Class<?> clazz, String name)
    {
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            if  (method.getName().equals(name)) {
                return method;
            }
        }
        return null;
    }
393485
protected function isColumnSetLocally($name)
	{
		$columns = $this->getColumns();
		return array_contains(
			$columns,
			function($descriptor) use ($name)
			{
				$alias = $descriptor[2];
				$column = $descriptor[1];
				return $name === (null === $alias ? $column : $alias);
			}
		);
	}
951514
public boolean containsMethod(final String name) {
      if (StringUtils.isNullOrBlank(name)) {
         return false;
      }
      return ClassDescriptorCache.getInstance()
                                 .getClassDescriptor(clazz)
                                 .getMethods(accessAll)
                                 .stream()
                                 .anyMatch(f -> f.getName().equals(name));
   }
954360
public static Method getMethod(Class<?> clazz, String name) {
        return getMethod(clazz, name, false);
    }
913291
public function getColumnName($name)
    {
        if (isset($this->map[$name])) {
            return $this->map[$name]->getColumn();
        }

        return null;
    }
1042775
public function getColumn($name)
    {

        // check all the columns
        foreach ($this->columns as $index => $column) {
            if ($name == $index) {
                return $column;
            }

            // recursivity
            if (method_exists($column, 'hasColumn')) {
               if ($column->hasColumn($name)) {
                   return $column->getColumn($name);
               }
            }
        }

        return null;
    }
24581
public boolean removeColumn(String name) {
    if (getColumnIndex(name) < 0)
      return false;
    this.mColumns.remove(getColumnIndex(name));
    return true;
  }
623036
public function getMethod($name)
    {
        return (isset($this->_methods[$name])) ? $this->_methods[$name] : null;
    }
259681
public function getClassName($name)
    {
        if (!$this->has($name)) {
            return false;
        }
        $helper = $this->get($name);
        return get_class($helper);
    }
682636
public function isValid($name)
    {
        if (parent::isValid($name)) {
            return true;
        }
        if (is_array($name)) {
            list($cls, $method) = $name;
            if (is_object($cls)) {
                return false; // No need to convert
            }
            if (is_array($method)) {
                return true; // Need to convert
            }
        } elseif (is_string($name) && strpos($name, '::') > 0) {
            list($cls, $method) = explode('::', $name);
        } else {
            return false; // Can't handle this, maybe already callable
        }

        /** @deprecated Deprecated since 3.3, to be removed in 4.0. */
        if (isset($this->classmap[$cls])) {
            return true; // Will use service definition
        }
        if (!class_exists($cls) || !method_exists($cls, $method)) {
            return false; // Can't handle this
        }
        $refMethod = new \ReflectionMethod($cls, $method);
        if ($refMethod->isStatic()) {
            return false; // Already valid
        }
        $constructor = $refMethod->getDeclaringClass()->getConstructor();
        // We can create the class if no constructor params, else can't handle it
        return $constructor === null || $constructor->getNumberOfRequiredParameters() === 0;
    }
60414
public function getMethod($name)
    {
        if ($this->reflected->hasMethod($name))
            return $this->annotations['methods'][$name];

        return null;
    }
787855
public function getColumnDecorators($name)
    {
        $dec = $this->columns[$name];

        return is_array($dec) ? $dec : [$dec];
    }