@param boolean $is_static

@return $this
778766
public function setStatic($is_static) {
    if ($is_static) {
      if (!isset($this->static)) {
        $this->static = Token::_static();
        $this->visibility->after([Token::space(), $this->static]);
      }
    }
    else {
      if (isset($this->static)) {
        // Remove whitespace after static keyword.
        $this->static->next()->remove();
        // Remove static keyword.
        $this->static->remove();
      }
    }
    return $this;
  }
493002
static function dbd($bool = true)
	{
		global $php;
		if($bool) $php->db->debug = true;
		else $php->db->debug = false;
	}
515081
public static function __static()
	{
		Aspect::$aspectTests = array(
			ASPECT_LOCATION => Aspect::$locationTest,
			ASPECT_CONCEPT => Aspect::$conceptTest,
			ASPECT_COMPLETE_SCENARIO => Aspect::$completeScenarioTest,
			ASPECT_COMPLETE_SEGMENT => Aspect::$completeSegmentTest,
			ASPECT_ENTITY_IDENTIFIER => Aspect::$entityIdentifierTest,
			ASPECT_PERIOD => Aspect::$periodTest,
			ASPECT_NON_XDT_SCENARIO => Aspect::$nonXDTScenarioTest,
			ASPECT_NON_XDT_SEGMENT => Aspect::$nonXDTSegmentTest,
			ASPECT_UNIT => Aspect::$unitTest,
		);
	}
305115
static function instance( $module_id, $slug = false, $is_init = false ) {
            if ( empty( $module_id ) ) {
                return false;
            }

            /**
             * Load the essential static data prior to initiating FS_Plugin_Manager since there's an essential MS network migration logic that needs to be executed prior to the initiation.
             */
            self::_load_required_static();

            if ( ! is_numeric( $module_id ) ) {
                if ( ! $is_init && true === $slug ) {
                    $is_init = true;
                }

                $slug = $module_id;

                $module = FS_Plugin_Manager::instance( $slug )->get();

                if ( is_object( $module ) ) {
                    $module_id = $module->id;
                }
            }

            $key = 'm_' . $module_id;

            if ( ! isset( self::$_instances[ $key ] ) ) {
                self::$_instances[ $key ] = new Freemius( $module_id, $slug, $is_init );
            }

            return self::$_instances[ $key ];
        }
662754
def static(cls):
  
  """
  for attr in dir(cls):
      im_func = getattr(getattr(cls, attr), 'im_func', None)
      if im_func:
        setattr(cls, attr, staticmethod(im_func))

  return cls
60877
public function update()
    {
        $s = new static();

        $where = "id = {$s::$ID}";

        return self::$db->update($s::$entity_table, $this->db_fields, $where);
    }
900783
public function set_status($status = self::STATUS_ACTIVE) {
        $this->statusactive = $status == static::STATUS_ACTIVE;
        $this->statussuspended = $status == static::STATUS_SUSPENDED;
        $this->statusnotcurrent = $status == static::STATUS_NOT_CURRENT;

        return $this;
    }
1179769
public function setActive() {
		if (! $this->_active) {
			$this->addClass(self::CLASS_ACTIVE);
			$this->_active = true;
		}
		
		return $this;
	}
431166
public static function __static()
	{
		SequenceTypes::$Void = SequenceType::WithTypeCode( XmlTypeCode::None );
		SequenceTypes::$Item = SequenceType::WithTypeCode( XmlTypeCode::Item );
		SequenceTypes::$ItemS = SequenceType::WithTypeCodeAndCardinality( XmlTypeCode::Item, XmlTypeCardinality::ZeroOrMore );
		SequenceTypes::$Node = SequenceType::WithTypeCode( XmlTypeCode::Node );
		SequenceTypes::$ProcessingInstruction = SequenceType::WithTypeCode( XmlTypeCode::ProcessingInstruction );
		SequenceTypes::$Text = SequenceType::WithTypeCode( XmlTypeCode::Text );
		SequenceTypes::$Comment = SequenceType::WithTypeCode( XmlTypeCode::Comment );
		SequenceTypes::$Element = SequenceType::WithTypeCode( XmlTypeCode::Element );
		SequenceTypes::$Attribute = SequenceType::WithTypeCode( XmlTypeCode::Attribute );
		SequenceTypes::$Document = SequenceType::WithTypeCode( XmlTypeCode::Document );
		SequenceTypes::$Boolean = SequenceType::WithTypeCode( XmlTypeCode::Boolean );
		SequenceTypes::$AnyAtomicType = SequenceType::WithTypeCode( XmlTypeCode::AnyAtomicType );
		SequenceTypes::$AnyAtomicTypeO = SequenceType::WithTypeCodeAndCardinality( XmlTypeCode::AnyAtomicType, XmlTypeCardinality::ZeroOrOne );
		SequenceTypes::$Double = SequenceType::WithTypeCode( XmlTypeCode::Double );
		SequenceTypes::$Float = SequenceType::WithTypeCode( XmlTypeCode::Float );
		SequenceTypes::$Date = SequenceType::WithTypeCode( XmlTypeCode::Date );
		SequenceTypes::$Time = SequenceType::WithTypeCode( XmlTypeCode::Time );
		SequenceTypes::$DateTime = SequenceType::WithTypeCode( XmlTypeCode::DateTime );
		SequenceTypes::$StringX = SequenceType::WithTypeCodeAndCardinality (XmlTypeCode::String, XmlTypeCardinality::ZeroOrOne );
		SequenceTypes::$Int = SequenceType::WithTypeCode( XmlTypeCode::Int );
		SequenceTypes::$AnyUri = SequenceType::WithTypeCode( XmlTypeCode::AnyUri );
	}
796268
public function isStatic($status = null)
    {
        $this->is_static = $status !== null ? $status : $this->is_static;
        return $this->is_static ;
    }
1169338
public function getOnlyFillable()
    {
        $list = [];

        foreach ($this->items as $item) {
            if ($item->fillable) {
                $list[] = $item;
            }
        }

        return new static($list);
    }
407531
public static function __static()
	{
		InstanceFactsIterator::$itemSubstitutionGroup = array( \XBRL_Constants::$xbrliItem );
		InstanceFactsIterator::$tupleSubstitutionGroup = array( \XBRL_Constants::$xbrliTuple );
		InstanceFactsIterator::$nodeTest = XmlQualifiedNameTest::create( "substitutionGroup" );
	}
710026
public function setStaticContentUseAlternative(string $static_content_use_alternative = "D") : CNabuDataObject
    {
        if ($static_content_use_alternative === null) {
            throw new ENabuCoreException(
                    ENabuCoreException::ERROR_NULL_VALUE_NOT_ALLOWED_IN,
                    array("\$static_content_use_alternative")
            );
        }
        $this->setValue('nb_site_static_content_use_alternative', $static_content_use_alternative);
        
        return $this;
    }
503464
public function disableCreatingCheck(bool $disable = true)
    {
        $this->builder()->getFooter()->disableCreatingCheck($disable);

        return $this;
    }
20226
public static function __static()
	{
		// NameValue::$nameStartChar = "[:_\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nl}]";
		NameValue::$nameStartChar = SchemaTypes::$nameStartChar;
		NameValue::$nameChar = SchemaTypes::$nameChar;
		NameValue::$name = SchemaTypes::$name;
		NameValue::$ncName = SchemaTypes::$ncName;
	}
924562
private static function staticContextIsOk($self, $static, $method)
    {
        try {
            $Rm = new \ReflectionMethod($static, $method);
            $Dc = $Rm->getDeclaringClass();
            if (!$Dc) {
                if (self::$debug) {
                    self::debug("Failed to get geclaring class for $static::$method");
                }
                return false;
            }

            $decl_class = $Dc->getName();
            if ($decl_class === $self) {
                return true;
            }

            // In PHP 5.5 the declared class is actually correct class, but it never a trait.
            // So we need to find the actual trait then if it is applicable to the class
            $Dt = self::getDeclaringTrait($decl_class, $method);
            if (!$Dt) {
                if (self::$debug) {
                    self::debug("Failed to get geclaring trait for $static::$method ($decl_class::$method");
                }
                return false;
            }

            if ($Dt->getName() === $self) {
                return true;
            }
        } catch (\ReflectionException $e) {
            if (self::$debug) {
                self::debug("Failed to get reflection method for $static::$method: $e");
            }
        }

        return false;
    }
1088656
public function newQuery()
    {
        return new static(
            $this->cache,
            $this->connection,
            $this->grammar,
            $this->processor,
            $this->cacheTag
        );
    }