# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _compoundsubproblem
else:
    import _compoundsubproblem

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import ooflib.SWIG.engine.csubproblem
import ooflib.SWIG.common.coord
import ooflib.SWIG.common.doublevec
import ooflib.SWIG.common.lock
import ooflib.SWIG.engine.element
import ooflib.SWIG.engine.edge
import ooflib.SWIG.engine.field
import ooflib.SWIG.engine.femesh
import ooflib.SWIG.common.cmicrostructure
import ooflib.SWIG.common.pixelgroup
import ooflib.SWIG.common.pixelattribute
import ooflib.SWIG.common.timestamp
import ooflib.SWIG.engine.node
import ooflib.SWIG.engine.pointdata
import ooflib.SWIG.engine.material
import ooflib.SWIG.common.abstractimage
import ooflib.SWIG.common.ccolor
import ooflib.SWIG.engine.property
import ooflib.SWIG.engine.meshiterator
import ooflib.SWIG.engine.fieldindex
import ooflib.SWIG.engine.planarity
import ooflib.SWIG.engine.freedom
import ooflib.SWIG.engine.outputval
import ooflib.SWIG.engine.mastercoord
import ooflib.SWIG.engine.elementnodeiterator
import ooflib.SWIG.engine.gausspoint
import ooflib.SWIG.engine.equation
import ooflib.SWIG.engine.flux
import ooflib.SWIG.engine.nodalequation
import ooflib.SWIG.engine.linearizedsystem
import ooflib.SWIG.engine.sparsemat
class CIntersectionSubProblem(ooflib.SWIG.engine.csubproblem.CSubProblem):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, arg3):
        _compoundsubproblem.CIntersectionSubProblem_swiginit(self, _compoundsubproblem.new_CIntersectionSubProblem(arg2, arg3))
    precomputeLock = property(_compoundsubproblem.CIntersectionSubProblem_precomputeLock_get, _compoundsubproblem.CIntersectionSubProblem_precomputeLock_set)
    precomputeRequired = property(_compoundsubproblem.CIntersectionSubProblem_precomputeRequired_get, _compoundsubproblem.CIntersectionSubProblem_precomputeRequired_set)
    __swig_destroy__ = _compoundsubproblem.delete_CIntersectionSubProblem

# Register CIntersectionSubProblem in _compoundsubproblem:
_compoundsubproblem.CIntersectionSubProblem_swigregister(CIntersectionSubProblem)
class CUnionSubProblem(ooflib.SWIG.engine.csubproblem.CSubProblem):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, arg3):
        _compoundsubproblem.CUnionSubProblem_swiginit(self, _compoundsubproblem.new_CUnionSubProblem(arg2, arg3))
    precomputeLock = property(_compoundsubproblem.CUnionSubProblem_precomputeLock_get, _compoundsubproblem.CUnionSubProblem_precomputeLock_set)
    precomputeRequired = property(_compoundsubproblem.CUnionSubProblem_precomputeRequired_get, _compoundsubproblem.CUnionSubProblem_precomputeRequired_set)
    __swig_destroy__ = _compoundsubproblem.delete_CUnionSubProblem

# Register CUnionSubProblem in _compoundsubproblem:
_compoundsubproblem.CUnionSubProblem_swigregister(CUnionSubProblem)
class CXorSubProblem(ooflib.SWIG.engine.csubproblem.CSubProblem):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, arg3):
        _compoundsubproblem.CXorSubProblem_swiginit(self, _compoundsubproblem.new_CXorSubProblem(arg2, arg3))
    precomputeLock = property(_compoundsubproblem.CXorSubProblem_precomputeLock_get, _compoundsubproblem.CXorSubProblem_precomputeLock_set)
    precomputeRequired = property(_compoundsubproblem.CXorSubProblem_precomputeRequired_get, _compoundsubproblem.CXorSubProblem_precomputeRequired_set)
    __swig_destroy__ = _compoundsubproblem.delete_CXorSubProblem

# Register CXorSubProblem in _compoundsubproblem:
_compoundsubproblem.CXorSubProblem_swigregister(CXorSubProblem)
class CComplementSubProblem(ooflib.SWIG.engine.csubproblem.CSubProblem):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2):
        _compoundsubproblem.CComplementSubProblem_swiginit(self, _compoundsubproblem.new_CComplementSubProblem(arg2))
    precomputeLock = property(_compoundsubproblem.CComplementSubProblem_precomputeLock_get, _compoundsubproblem.CComplementSubProblem_precomputeLock_set)
    precomputeRequired = property(_compoundsubproblem.CComplementSubProblem_precomputeRequired_get, _compoundsubproblem.CComplementSubProblem_precomputeRequired_set)
    __swig_destroy__ = _compoundsubproblem.delete_CComplementSubProblem

# Register CComplementSubProblem in _compoundsubproblem:
_compoundsubproblem.CComplementSubProblem_swigregister(CComplementSubProblem)
# -*- python -*-

# This software was produced by NIST, an agency of the U.S. government,
# and by statute is not subject to copyright in the United States.
# Recipients of this software assume all responsibilities associated
# with its operation, modification and maintenance. However, to
# facilitate maintenance we ask that before distributing modified
# versions of this software, you first contact the authors at
# oof_manager@nist.gov. 

from ooflib.common import registeredclass
from ooflib.common import debug
from ooflib.engine import subproblemcontext
from ooflib.engine import subproblemtype

class BinaryCompoundSubProblem(subproblemtype.SubProblemType):
    def __init__(self, one, another):
        self.one = one
        self.another = another
    def get_dependencies(self):
        return [self.one, self.another]
    def create(self):
        return self.cclass(
            subproblemcontext.subproblems[self.one].getObject(),
            subproblemcontext.subproblems[self.another].getObject())

binarycompoundparams = [
    subproblemcontext.SubProblemParameter(
        'one', tip='The name of a subproblem.'),
    subproblemcontext.SubProblemParameter(
        'another', tip='The name of another subproblem.')]

class UnionSubProblem(BinaryCompoundSubProblem):
    cclass = CUnionSubProblem

registeredclass.Registration(
    "Union",
    subproblemtype.SubProblemType,
    UnionSubProblem,
    ordering=4,
    params=binarycompoundparams,
    tip='Construct a Subproblem from the union of two previously defined Subproblems',
    discussion="""<para>

    Create a new &subproblem; from two existing &subproblems; in the
    same &mesh;.  Any &elem; included in either of the two existing
    &subproblems; will be included in the new one.

    </para>""")

class IntersectionSubProblem(BinaryCompoundSubProblem):
    cclass = CIntersectionSubProblem

registeredclass.Registration(
    "Intersection",
    subproblemtype.SubProblemType,
    IntersectionSubProblem,
    ordering=4.1,
    params=binarycompoundparams,
    tip='Construct a Subproblem from the intersection of two previously defined Subproblems',
    discussion="""<para>

    Create a new &subproblem; from two existing &subproblems; in the
    same &mesh;.  Any &elem; included in both of the two existing
    &subproblems; will be included in the new one.

    </para>""")

class XorSubProblem(BinaryCompoundSubProblem):
    cclass = CXorSubProblem

registeredclass.Registration(
    "Xor",
    subproblemtype.SubProblemType,
    XorSubProblem,
    ordering=4.2,
    params=binarycompoundparams,
    tip='Construct a Subproblem from the exclusive or of two previously defined Subproblems.',
    discussion="""<para>

    Create a new &subproblem; from two existing &subproblems; in the
    same &mesh;.  Any &elem; included in just one of the two
    existing &subproblems; will be included in the new one.

    </para>""")

#######################################

_old_init_ = CComplementSubProblem.__init__
def _CComplementSubProblem___init__(self, subprob):
# Convert paths into subproblem objects
    subprob_obj = subproblemcontext.subproblems[subprob].getObject()
    _old_init_(self, subprob_obj)
CComplementSubProblem.__init__ = _CComplementSubProblem___init__

class ComplementSubProblem(subproblemtype.SubProblemType):
    def __init__(self, complement_of):
        self.complement_of = complement_of
    def create(self):
        return CComplementSubProblem(self.complement_of)
    def get_dependencies(self):
        return [self.complement_of]

registeredclass.Registration(
    "Complement",
    subproblemtype.SubProblemType,
    ComplementSubProblem,
    ordering=5,
    params=[subproblemcontext.SubProblemParameter('complement_of',
                                             tip="The name of a subproblem")],
    tip="Construct a Subproblem from the elements that aren't in another subproblem.",
    discussion="""<para>

    Create a new &subproblem; from the complement of an existing
    &subproblem;.  All &mesh; &elems; that aren't in the given
    &subproblem; will be in the new one.

    </para>""")




