// Generated by gtkmmproc -- DO NOT MODIFY!


#include <libgdamm/dictconstraint.h>
#include <libgdamm/private/dictconstraint_p.h>

/* $Id: dicttype.ccg,v 1.3 2006/11/08 00:52:25 murrayc Exp $ */
// -*- C++ -*- // this is for the .ccg, I realize gensig puts one in

/* dict.cc
 * 
 * Copyright 2006 libgdamm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <libgda/gda-dict-type.h>
#include <libgdamm/dicttable.h>
#include <libgdamm/dictfield.h>
#include <libgdamm/dicttype.h>
#include <libgdamm/dictdatabase.h>
//#include <libgdamm/connection.h>
#include <libgda/gda-enum-types.h>

namespace Gnome
{


} /* namespace Gnome */


namespace
{
} // anonymous namespace

// static
GType Glib::Value<Gnome::Gda::DictConstraintType>::value_type()
{
  return gda_dict_constraint_type_get_type();
}

// static
GType Glib::Value<Gnome::Gda::DictConstraintFkAction>::value_type()
{
  return gda_dict_constraint_fk_action_get_type();
}


namespace Glib
{

Glib::RefPtr<Gnome::Gda::DictConstraint> wrap(GdaDictConstraint* object, bool take_copy)
{
  return Glib::RefPtr<Gnome::Gda::DictConstraint>( dynamic_cast<Gnome::Gda::DictConstraint*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Glib */


namespace Gnome
{

namespace Gda
{


/* The *_Class implementation: */

const Glib::Class& DictConstraint_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &DictConstraint_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gda_dict_constraint_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:
  XmlStorage::add_interface(get_type());
  Referer::add_interface(get_type());

  }

  return *this;
}

void DictConstraint_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);

#ifdef GLIBMM_VFUNCS_ENABLED
#endif //GLIBMM_VFUNCS_ENABLED

#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
}

#ifdef GLIBMM_VFUNCS_ENABLED
#endif //GLIBMM_VFUNCS_ENABLED

#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED


Glib::ObjectBase* DictConstraint_Class::wrap_new(GObject* object)
{
  return new DictConstraint((GdaDictConstraint*)object);
}


/* The implementation: */

GdaDictConstraint* DictConstraint::gobj_copy()
{
  reference();
  return gobj();
}

DictConstraint::DictConstraint(const Glib::ConstructParams& construct_params)
:
  Gda::Object(construct_params)
{

}

DictConstraint::DictConstraint(GdaDictConstraint* castitem)
:
  Gda::Object((GdaObject*)(castitem))
{}

DictConstraint::~DictConstraint()
{}


DictConstraint::CppClassType DictConstraint::dictconstraint_class_; // initialize static member

GType DictConstraint::get_type()
{
  return dictconstraint_class_.init().get_type();
}

GType DictConstraint::get_base_type()
{
  return gda_dict_constraint_get_type();
}


DictConstraint::DictConstraint(const Glib::RefPtr<DictTable>& table, DictConstraintType type)
:
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(0),
  Gda::Object(Glib::ConstructParams(dictconstraint_class_.init(), "table", Glib::unwrap(table), "type", ((GdaDictConstraintType)(type)), static_cast<char*>(0)))
{
  

}

DictConstraint::DictConstraint(const Glib::RefPtr<DictDatabase>& db)
:
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(0),
  Gda::Object(Glib::ConstructParams(dictconstraint_class_.init(), "db", Glib::unwrap(db), static_cast<char*>(0)))
{
  

}

Glib::RefPtr<DictConstraint> DictConstraint::create(const Glib::RefPtr<DictTable>& table, DictConstraintType type)
{
  return Glib::RefPtr<DictConstraint>( new DictConstraint(table, type) );
}
Glib::RefPtr<DictConstraint> DictConstraint::create(const Glib::RefPtr<DictDatabase>& db)
{
  return Glib::RefPtr<DictConstraint>( new DictConstraint(db) );
}
DictConstraintType DictConstraint::get_constraint_type() const
{
  return ((DictConstraintType)(gda_dict_constraint_get_constraint_type(const_cast<GdaDictConstraint*>(gobj()))));
}

bool DictConstraint::equal(const Glib::RefPtr<const DictConstraint>& cstr2) const
{
  return gda_dict_constraint_equal(const_cast<GdaDictConstraint*>(gobj()), const_cast<GdaDictConstraint*>(Glib::unwrap(cstr2)));
}

Glib::RefPtr<DictTable> DictConstraint::get_table()
{

  Glib::RefPtr<DictTable> retvalue = Glib::wrap(gda_dict_constraint_get_table(gobj()));
  if(retvalue)
    retvalue->reference(); //The function does not do a ref for us.
  return retvalue;

}

Glib::RefPtr<const DictTable> DictConstraint::get_table() const
{
  return const_cast<DictConstraint*>(this)->get_table();
}

bool DictConstraint::uses_field(const Glib::RefPtr<const DictField>& field) const
{
  return gda_dict_constraint_uses_field(const_cast<GdaDictConstraint*>(gobj()), const_cast<GdaDictField*>(Glib::unwrap(field)));
}

void DictConstraint::pkey_set_fields(const Glib::SListHandle< Glib::RefPtr<DictField> >& fields)
{
gda_dict_constraint_pkey_set_fields(gobj(), fields.data()); 
}

Glib::SListHandle< Glib::RefPtr<DictField> > DictConstraint::pkey_get_fields()
{
  return Glib::SListHandle< Glib::RefPtr<DictField> >(gda_dict_constraint_pkey_get_fields(gobj()), Glib::OWNERSHIP_SHALLOW);
}

Glib::SListHandle< Glib::RefPtr<const DictField> > DictConstraint::pkey_get_fields() const
{
  return Glib::SListHandle< Glib::RefPtr<const DictField> >(gda_dict_constraint_pkey_get_fields(const_cast<GdaDictConstraint*>(gobj())), Glib::OWNERSHIP_SHALLOW);
}

Glib::RefPtr<DictTable> DictConstraint::fkey_get_ref_table()
{

  Glib::RefPtr<DictTable> retvalue = Glib::wrap(gda_dict_constraint_fkey_get_ref_table(gobj()));
  if(retvalue)
    retvalue->reference(); //The function does not do a ref for us.
  return retvalue;

}

Glib::RefPtr<const DictTable> DictConstraint::fkey_get_ref_table() const
{
  return const_cast<DictConstraint*>(this)->fkey_get_ref_table();
}

void DictConstraint::fkey_set_actions(DictConstraintFkAction on_update, DictConstraintFkAction on_delete)
{
gda_dict_constraint_fkey_set_actions(gobj(), ((GdaDictConstraintFkAction)(on_update)), ((GdaDictConstraintFkAction)(on_delete))); 
}

void DictConstraint::fkey_get_actions(DictConstraintFkAction& on_update, DictConstraintFkAction& on_delete)
{
gda_dict_constraint_fkey_get_actions(gobj(), ((GdaDictConstraintFkAction*) &(on_update)), ((GdaDictConstraintFkAction*) &(on_delete))); 
}

void DictConstraint::unique_set_fields(const Glib::SListHandle< Glib::RefPtr<DictField> >& fields)
{
gda_dict_constraint_unique_set_fields(gobj(), fields.data()); 
}

Glib::SListHandle< Glib::RefPtr<DictField> > DictConstraint::unique_get_fields()
{
  return Glib::SListHandle< Glib::RefPtr<DictField> >(gda_dict_constraint_unique_get_fields(gobj()), Glib::OWNERSHIP_SHALLOW);
}

Glib::SListHandle< Glib::RefPtr<const DictField> > DictConstraint::unique_get_fields() const
{
  return Glib::SListHandle< Glib::RefPtr<const DictField> >(gda_dict_constraint_unique_get_fields(const_cast<GdaDictConstraint*>(gobj())), Glib::OWNERSHIP_SHALLOW);
}

void DictConstraint::not_null_set_field(const Glib::RefPtr<DictField>& field)
{
gda_dict_constraint_not_null_set_field(gobj(), Glib::unwrap(field)); 
}

Glib::RefPtr<DictField> DictConstraint::not_null_get_field()
{
  return Glib::wrap(gda_dict_constraint_not_null_get_field(gobj()));
}

Glib::RefPtr<const DictField> DictConstraint::not_null_get_field() const
{
  return Glib::wrap(gda_dict_constraint_not_null_get_field(const_cast<GdaDictConstraint*>(gobj())));
}


#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<bool> DictConstraint::property_user_constraint() 
{
  return Glib::PropertyProxy<bool>(this, "user-constraint");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<bool> DictConstraint::property_user_constraint() const
{
  return Glib::PropertyProxy_ReadOnly<bool>(this, "user-constraint");
}
#endif //GLIBMM_PROPERTIES_ENABLED


#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED

#ifdef GLIBMM_VFUNCS_ENABLED
#endif //GLIBMM_VFUNCS_ENABLED


} // namespace Gda

} // namespace Gnome


