path: root/source4/param/param.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.35
#
# Don't modify this file, modify the SWIG interface instead.

import _param
import new
new_instancemethod = new.instancemethod
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class LoadParm(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        _param.LoadParm_swiginit(self,_param.new_LoadParm(*args, **kwargs))
    def load(*args, **kwargs):
        """
        S.load(filename) -> None
        Load specified file.
        """
        return _param.LoadParm_load(*args, **kwargs)

    def load_default(*args, **kwargs):
        """
        S.load_default() -> None
        Load default smb.conf file.
        """
        return _param.LoadParm_load_default(*args, **kwargs)

    def configfile(*args, **kwargs):
        """
        S.configfile() -> string
        Return name of last config file that was loaded.
        """
        return _param.LoadParm_configfile(*args, **kwargs)

    def is_mydomain(*args, **kwargs):
        """
        S.is_mydomain(domain_name) -> bool
        Check whether the specified name matches our domain name.
        """
        return _param.LoadParm_is_mydomain(*args, **kwargs)

    def is_myname(*args, **kwargs):
        """
        S.is_myname(netbios_name) -> bool
        Check whether the specified name matches one of our netbios names.
        """
        return _param.LoadParm_is_myname(*args, **kwargs)

    def set(*args, **kwargs):
        """
        S.set(name, value) -> bool
        Change a parameter.
        """
        return _param.LoadParm_set(*args, **kwargs)

    __swig_destroy__ = _param.delete_LoadParm
LoadParm.default_service = new_instancemethod(_param.LoadParm_default_service,None,LoadParm)
LoadParm.load = new_instancemethod(_param.LoadParm_load,None,LoadParm)
LoadParm.load_default = new_instancemethod(_param.LoadParm_load_default,None,LoadParm)
LoadParm.__len__ = new_instancemethod(_param.LoadParm___len__,None,LoadParm)
LoadParm.__getitem__ = new_instancemethod(_param.LoadParm___getitem__,None,LoadParm)
LoadParm.configfile = new_instancemethod(_param.LoadParm_configfile,None,LoadParm)
LoadParm.is_mydomain = new_instancemethod(_param.LoadParm_is_mydomain,None,LoadParm)
LoadParm.is_myname = new_instancemethod(_param.LoadParm_is_myname,None,LoadParm)
LoadParm.use = new_instancemethod(_param.LoadParm_use,None,LoadParm)
LoadParm.set = new_instancemethod(_param.LoadParm_set,None,LoadParm)
LoadParm.get = new_instancemethod(_param.LoadParm_get,None,LoadParm)
LoadParm_swigregister = _param.LoadParm_swigregister
LoadParm_swigregister(LoadParm)

class loadparm_service(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
loadparm_service.volume_label = new_instancemethod(_param.loadparm_service_volume_label,None,loadparm_service)
loadparm_service.printername = new_instancemethod(_param.loadparm_service_printername,None,loadparm_service)
loadparm_service.maxprintjobs = new_instancemethod(_param.loadparm_service_maxprintjobs,None,loadparm_service)
loadparm_service_swigregister = _param.loadparm_service_swigregister
loadparm_service_swigregister(loadparm_service)

class ParamFile(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        _param.ParamFile_swiginit(self,_param.new_ParamFile(*args, **kwargs))
    def add_section(*args, **kwargs):
        """
        S.add_section(name) -> section
        Add a new section.
        """
        return _param.ParamFile_add_section(*args, **kwargs)

    def first_section(*args, **kwargs):
        """
        S.first_section() -> section
        Find first section
        """
        return _param.ParamFile_first_section(*args, **kwargs)

    def next_section(*args, **kwargs):
        """
        S.next_section(prev) -> section
        Find next section
        """
        return _param.ParamFile_next_section(*args, **kwargs)

    def read(*args, **kwargs):
        """
        S.read(filename) -> bool
        Read a filename.
        """
        return _param.ParamFile_read(*args, **kwargs)

    def __getitem__(self, name):
        ret = self.get_section(name)
        if ret is None:
            raise KeyError("No such section %s" % name)
        return ret

    class SectionIterator:
        def __init__(self, param):
            self.param = param
            self.key = None

        def __iter__(self):
            return self
            
        def next(self):
            if self.key is None:
                self.key = self.param.first_section()
                if self.key is None:
                    raise StopIteration
                return self.key
            else:
                self.key = self.param.next_section(self.key)
                if self.key is None:
                    raise StopIteration
                return self.key

    def __iter__(self):
        return self.SectionIterator(self)

    __swig_destroy__ = _param.delete_ParamFile
ParamFile.get_section = new_instancemethod(_param.ParamFile_get_section,None,ParamFile)
ParamFile.add_section = new_instancemethod(_param.ParamFile_add_section,None,ParamFile)
ParamFile.get = new_instancemethod(_param.ParamFile_get,None,ParamFile)
ParamFile.get_string = new_instancemethod(_param.ParamFile_get_string,None,ParamFile)
ParamFile.set_string = new_instancemethod(_param.ParamFile_set_string,None,ParamFile)
ParamFile.set = new_instancemethod(_param.ParamFile_set,None,ParamFile)
ParamFile.first_section = new_instancemethod(_param.ParamFile_first_section,None,ParamFile)
ParamFile.next_section = new_instancemethod(_param.ParamFile_next_section,None,ParamFile)
ParamFile.read = new_instancemethod(_param.ParamFile_read,None,ParamFile)
ParamFile.write = new_instancemethod(_param.ParamFile_write,None,ParamFile)
ParamFile_swigregister = _param.ParamFile_swigregister
ParamFile_swigregister(ParamFile)

class param_opt(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    key = _swig_property(_param.param_opt_key_get)
    value = _swig_property(_param.param_opt_value_get)
    __swig_destroy__ = _param.delete_param_opt
param_opt.__str__ = new_instancemethod(_param.param_opt___str__,None,param_opt)
param_opt_swigregister = _param.param_opt_swigregister
param_opt_swigregister(param_opt)

class param_section(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    name = _swig_property(_param.param_section_name_get)
    def __getitem__(self, name):
        ret = self.get(name)
        if ret is None:
            raise KeyError("No such option %s" % name)
        return ret

    class ParamIterator:
        def __init__(self, section):
            self.section = section
            self.key = None

        def __iter__(self):
            return self
            
        def next(self):
            if self.key is None:
                self.key = self.section.first_parameter()
                if self.key is None:
                    raise StopIteration
                return self.key
            else:
                self.key = self.section.next_parameter(self.key)
                if self.key is None:
                    raise StopIteration
                return self.key

    def __iter__(self):
        return self.ParamIterator(self)

    def __init__(self, *args, **kwargs): 
        _param.param_section_swiginit(self,_param.new_param_section(*args, **kwargs))
    __swig_destroy__ = _param.delete_param_section
param_section.get = new_instancemethod(_param.param_section_get,None,param_section)
param_section.first_parameter = new_instancemethod(_param.param_section_first_parameter,None,param_section)
param_section.next_parameter = new_instancemethod(_param.param_section_next_parameter,None,param_section)
param_section_swigregister = _param.param_section_swigregister
param_section_swigregister(param_section)


cvar = _param.cvar