#ifndef NO_MODEL_H
#define NO_MODEL_H

#ifndef MODEL_H
#include "Model.h"
#endif

#ifndef MODEL_KIT_H
#include "Model_kit.h"
#endif

#ifndef ATOM_H
#include "Atom.h"
#endif

#ifndef BOND_H
#include "Bond.h"
#endif

#ifndef MOLECULE_H
#include "Molecule.h"
#endif

#ifndef USER_H
#include "User.h"
#endif

#ifndef CREATE_H
#include "Create.h"
#endif

namespace MM
{
class No_model : public Model
{
    Model *             clone () const                                          {warning(); return 0;}
    void                copy (int /*n*/, Expanded_atom_group * /*result*/)      {warning();}
    void                erase ()                                                {warning();}
    void                clear ()                                                {warning();}
    void                orphan_all ()                                           {warning();}
    void                remove_deads ()                                         {warning();}

    Model_kit &         kit ()                                                  {warning(); return nil<Model_kit>();}
    const Model_kit &   kit () const                                            {warning(); return nil<Model_kit>();}

    void                merge_model (Model * )                                  {warning();}

    void                move   (Vector_3D const&)                               {warning();}
    void                rotate (Vector_3D const& , double )                     {warning();}

    Atom &              atom_prototype ()                                       {warning(); return nil<Atom>();}
    void                set_atom_prototype (Atom * )                            {warning();}
    int                 atom_count     () const                                 {warning(); return 0;}
    Atom &              atom           (int )                                   {warning(); return nil<Atom>();}
    const Atom &        atom           (int ) const                             {warning(); return nil<Atom>();}
    void                add_atom       (Atom * )                                {warning();}
    void                erase          (Atom & )                                {warning();}

    Atom &              atom (const ID & )                                      {warning(); return nil<Atom>();}
    const Atom &        atom (const ID & ) const                                {warning(); return nil<Atom>();}

    Bond &              bond_prototype ()                                       {warning(); return nil<Bond>();}
    void                set_bond_prototype (Bond * /*adoptee*/)                     {warning();}
    int                 bond_count  () const                                    {warning(); return 0;}
    Bond &              bond        (int )                                      {warning(); return nil<Bond>();}
    const Bond &        bond        (int ) const                                {warning(); return nil<Bond>();}
    void                add_bond    (Bond * )                                   {warning();}

    void                detect_molecules()                                      {warning();}
    int                 molecule_count  () const                                {warning(); return 0;}
    Molecule &          molecule        (int )                                  {warning(); return nil<Molecule>();}
    const Molecule &    molecule        (int ) const                            {warning(); return nil<Molecule>();}
    void                add_molecule    (Molecule * )                           {warning();}
    Molecule *          orphan_molecule (Molecule & )                           {warning(); return 0;}
    void                reset_molecules ()                                      {warning();}

    int                 residue_count () const                                  {warning(); return 0;}
    Residue &           residue (int )                                          {warning(); return nil<Residue>();}
    Residue const &     residue (int ) const                                    {warning(); return nil<Residue>();}
    void                add_residue (Residue *)                                 {warning();}
    void                remove_dead_residues ()                                 {warning();}
    void                reset_residues ()                                       {warning();}

    int                 joint_count () const                                    {warning(); return 0;}
    Joint &             joint (int)                                             {warning(); return nil<Joint>();}
    Joint const &       joint (int) const                                       {warning(); return nil<Joint>();}
    Joint &             joint (Text const& /*local_id*/)                            {warning(); return nil<Joint>();}
    void                add_joint (Joint *)                                     {warning();}

    bool    save    (bool )                                                     {warning(); return false;}
    bool    save_as (Text const & , Text const & ,
                     Text * , bool )                                            {warning(); return false;}
    void    load    (Text const & , Text const & )                              {warning();}
    void    add     (Text const & , Text const & )                              {warning();}
    void    pull_on (Text const & , Text const & )                              {warning();}
    void    clear_local_ids ()                                                  {warning();}

protected:
    virtual void    warning() const
    {
        #ifndef NDEBUG
        to_user().warning ("Access to No_model.");
        #endif
    }

};

}//MM

#endif //NO_MODEL_H
