Remove is_default flag
321653
protected function resetDefault()
    {
        $defaultGroups = CustomerGroupQuery::create()
            ->filterByIsDefault(true)
            ->find();

        foreach ($defaultGroups as $defaultGroup) {
            $defaultGroup
                ->setIsDefault(false)
                ->save();
        }

    }
1268598
private function _applyDefaults() {
		foreach($this->_flags as $flag => $settings) {
			$this[$flag] = $settings['default'];
		}

		foreach($this->_options as $option => $settings) {
			// If the default is 0 we should still let it be set.
			if (!empty($settings['default']) || $settings['default'] === 0) {
				$this[$option] = $settings['default'];
			}
		}
	}
1212006
function  ( flag ){
    if( flag === undefined ) flag = true;
    this._dat[ 0|SCISSOR_ENABLE ] = flag|0;
    this._set |= SCISSOR_ENABLE_SET|0;
    return this;
  }
854748
function removeDefaults (schema, options) {
  options = options || {}
  
  schema.method('removeDefaults', function () {
    var self = this
    schema.eachPath(function (name, path) {
      var current = self._doc[name]
        , defaults = path.defaultValue

      // Check for numbers, as the schema will hold them as 
      // objects with path related properties
      if (toString.call(current) === '[object Number]') {
        current =  Number(current)
        defaults = Number(defaults)
      }

      // Remove property if it matches the default
      if (current === defaults) {
        delete self._doc[name]
      }
    })
    return this
  })
}
286871
def set_flag_sql(flag, value, colmn = nil, custom_table_name = table_name)
      colmn = determine_flag_colmn_for(flag) if colmn.nil?
      sql_set_for_flag(flag, colmn, value, custom_table_name)
    end
1218059
def _is_default(path, dest, name):
    '''
    
    '''
    subvol_id = __salt__['btrfs.subvolume_show'](path)[name]['subvolume id']
    def_id = __salt__['btrfs.subvolume_get_default'](dest)['id']
    return subvol_id == def_id
669160
def __pkg_upgrade_flags(self, flags):
        
        flag, skip = [], ""
        if flags[0] in self.args:
            for arg in self.args[3:]:
                if arg.startswith(flags[1]):
                    skip = Regex(arg.split("=")[1]).get()
                    self.args.remove(arg)
                if arg in flags:
                    flag.append(arg)
                    if arg in self.args:
                        self.args.remove(arg)
        return flag, skip
259129
void resetDefaultsFlag() {

        hasDefaultValues = false;

        for (int i = 0; i < colDefaults.length; i++) {
            hasDefaultValues = hasDefaultValues || colDefaults[i] != null;
        }
    }
1180246
public Message clearFlag(Flag ... flags) {
        if(flags != null) {
            short tmp=this.flags;
            for(Flag flag : flags)
                if(flag != null)
                    tmp&=~flag.value();
            this.flags=tmp;
        }
        return this;
    }
969047
@SuppressWarnings({"deprecation", "UnusedReturnValue", "WeakerAccess"})
    public BUILDER removeFlag(final AttributeAccess.Flag flag) {
        if (!isFlagPresent(flag)) {
            return (BUILDER) this; //if not present no need to remove
        }
        final int length = flags.length;
        final AttributeAccess.Flag[] newFlags = new AttributeAccess.Flag[length - 1];
        int k = 0;
        for (AttributeAccess.Flag flag1 : flags) {
            if (flag1 != flag) {
                newFlags[k] = flag1;
                k++;
            }
        }
        //noinspection deprecation
        flags = newFlags;
        return (BUILDER) this;
    }
1366999
def get_flag_value(self, name, default):  # pylint: disable=invalid-name
    

    value = self.__getattr__(name)
    if value is not None:  # Can't do if not value, b/c value might be '0' or ""
      return value
    else:
      return default
14168
def _default_cleanup(self):
        
        if not self.inplace:
            return

        shutil.move(
            os.path.join(self.build_lib, "bezier", "lib"),
            os.path.join("src", "bezier"),
        )
1318628
def is_default(self):
        '''
        
        '''
        for field in self._fields:
            if not field.is_default():
                return False
        return super(Container, self).is_default()
1070305
private static function RemoveUndefinedVars(){
            $oThis = self::CreateInstanceIfNotExists();
            $iOffset = 0;

            while(preg_match('/{\$(.*?)}/i', $oThis->sBuffer, $aMatches, PREG_OFFSET_CAPTURE, $iOffset)){
                $oThis->sBuffer = str_replace($aMatches[0][0], "false", $oThis->sBuffer);
                $iOffset = $aMatches[0][1]+strlen($aMatches[0][0]);
            }
        }
1028435
def editflags(fd, add_flags=0, remove_flags=0):
    

    if add_flags & remove_flags != 0:
        raise ValueError(
            'Added and removed flags shouldn\'t overlap',
            add_flags, remove_flags)

    # The ext2progs code uses int or unsigned long,
    # the kernel uses an implicit int,
    # let's be explicit here.
    flags_ptr = ffi.new('uint64_t*')
    flags_buf = ffi.buffer(flags_ptr)
    fcntl.ioctl(fd, lib.FS_IOC_GETFLAGS, flags_buf)
    prev_flags = flags_ptr[0]
    flags_ptr[0] |= add_flags
    # Python represents negative numbers with an infinite number of
    # ones in bitops, so this will work correctly.
    flags_ptr[0] &= ~remove_flags
    fcntl.ioctl(fd, lib.FS_IOC_SETFLAGS, flags_buf)
    return prev_flags & (add_flags | remove_flags)
581253
def option(flag)
      options.find do |o|
        o.flags.any? { |f| clean_key(f) == clean_key(flag) }
      end
    end
383250
def remove_flag(self, user=None, status=None):
        
        filter_kwargs = {
            'content_type': ContentType.objects.get_for_model(self),
            'object_id': self.id
        }
        update_filter_dict(filter_kwargs, user, status)
        get_flag_model().objects.filter(**filter_kwargs).delete()