Contact.h

// -*- C++ -*-
//
// Copyright (c) BULL S.A. 2000-2020, All Rights Reserved
//
// This file is part of Hurricane.
//
// Hurricane is free software: you can redistribute it  and/or  modify
// it under the terms of the GNU  Lesser  General  Public  License  as
// published by the Free Software Foundation, either version 3 of  the
// License, or (at your option) any later version.
//
// Hurricane is distributed in the hope that it will  be  useful,  but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN-
// TABILITY or FITNESS FOR A PARTICULAR PURPOSE. See  the  Lesser  GNU
// General Public License for more details.
//
// You should have received a copy of the Lesser  GNU  General  Public
// License along with Hurricane. If not, see
//                                     <http://www.gnu.org/licenses/>.
//
// +-----------------------------------------------------------------+
// |                  H U R R I C A N E                              |
// |     V L S I   B a c k e n d   D a t a - B a s e                 |
// |                                                                 |
// |  Author      :                       Remy Escassut              |
// |  E-mail      :            Jean-Paul.Chaput@lip6.fr              |
// | =============================================================== |
// |  C++ Header  :  "./hurricane/Commons.h"                         |
// +-----------------------------------------------------------------+
 
 
#pragma  once
#include "hurricane/Component.h"
#include "hurricane/Contacts.h"
 
 
namespace Hurricane {
 
  
// -------------------------------------------------------------------
// Class  :  "Hurricane::Contact".
 
  class Contact : public Component {
    private:
      static  FastRTTI  _fastRTTI;
    public:
      static  inline const FastRTTI& fastRTTI  (); 
      virtual        const FastRTTI& vfastRTTI () const; 
    public:
      typedef Component Inherit;
      const uint64_t  NoFlags           = 0;
      const uint64_t  RotateTopMetal    = (1 << 0);
      const uint64_t  RotateBottomMetal = (1 << 1);
      const uint64_t  AllRotate         = RotateTopMetal|RotateBottomMetal;
    public:
      class AnchorHook : public Hook {
        friend class Contact;
        public:
          typedef Hook Inherit;
        private:
                               AnchorHook   ( Contact* );
        public:
          virtual Component*   getComponent () const;
          virtual bool         isMaster     () const { return false; };
          virtual std::string  _getTypeName () const { return "Contact::AnchorHook"; };
          virtual std::string  _getString   () const;
          static  Hook*        _compToHook  ( Component* );
    };
 
    protected:
      Contact (       Net*      net
              , const Layer*    layer
              ,       DbU::Unit x
              ,       DbU::Unit y
              ,       DbU::Unit width
              ,       DbU::Unit height
              );
      Contact (       Net*       net
              ,       Component* anchor
              , const Layer*     layer
              ,       DbU::Unit  dx
              ,       DbU::Unit  dy
              ,       DbU::Unit  width
              ,       DbU::Unit  height
              );
    public:
      static inline void     enableCheckMinSize  ();
      static inline void     disableCheckMinSize ();
      static        Contact* create (       Net*      net
                                    , const Layer*    layer
                                    ,       DbU::Unit x
                                    ,       DbU::Unit y
                                    ,       DbU::Unit width =0
                                    ,       DbU::Unit height=0
                                    );
      static        Contact* create (       Component* anchor
                                    , const Layer*     layer
                                    ,       DbU::Unit  dx
                                    ,       DbU::Unit  dy
                                    ,       DbU::Unit  width =0
                                    ,       DbU::Unit  height=0
                                    );
    public:
      inline        bool         isRotatedTopMetal     () const;
      inline        bool         isRotatedBottomMetal  () const;
      virtual       Hooks        getHooks              () const;
      virtual       DbU::Unit    getX                  () const;
      virtual       DbU::Unit    getY                  () const;
      virtual       Point        getPosition           () const;
      virtual       Box          getBoundingBox        () const;
      virtual const Layer*       getLayer              () const {return _layer;};
      virtual       Box          getBoundingBox        ( const BasicLayer* ) const;
                    Hook*        getAnchorHook         () { return &_anchorHook; };
                    Component*   getAnchor             () const;
                    DbU::Unit    getDx                 () const { return _dx; };
                    DbU::Unit    getDy                 () const { return _dy; };
                    DbU::Unit    getWidth              () const { return _width; };
                    DbU::Unit    getHalfWidth          () const { return (_width / 2); };
                    DbU::Unit    getHeight             () const { return _height; };
                    DbU::Unit    getHalfHeight         () const { return (_height / 2); };
    public:                                            
      virtual       void         translate             ( const DbU::Unit& dx, const DbU::Unit& dy );
                    void         setLayer              ( const Layer* );
                    void         setWidth              ( DbU::Unit );
                    void         setHeight             ( DbU::Unit );
                    void         setSizes              ( DbU::Unit width, DbU::Unit height);
                    void         setX                  ( DbU::Unit );
                    void         setY                  ( DbU::Unit );
                    void         setPosition           ( DbU::Unit x, DbU::Unit y);
                    void         setPosition           ( const Point& );
                    void         setDx                 ( DbU::Unit );
                    void         setDy                 ( DbU::Unit );
                    void         setOffset             ( DbU::Unit dx, DbU::Unit dy);
      inline        void         setRotatedTopMetal    ( bool state );
      inline        void         setRotatedBottomMetal ( bool state );
    private:                                          
                    bool         _postCheck           ();
    protected:                                        
      virtual       void         _preDestroy          ();
    public:                                           
      virtual       void         _toJson              ( JsonWriter* ) const;
      virtual       std::string  _getTypeName         () const { return _TName("Contact"); };
      virtual       std::string  _getString           () const;
      virtual       Record*      _getRecord           () const;
    private:
      static bool        _checkMinSize;
             AnchorHook  _anchorHook;
      const  Layer*      _layer;
             uint64_t    _flags;
             DbU::Unit   _dx;
             DbU::Unit   _dy;
    protected:
             DbU::Unit   _width;
             DbU::Unit   _height;
  };
 
  
  inline const FastRTTI& Contact::fastRTTI () { return _fastRTTI; }
  
  inline void  Contact::enableCheckMinSize    () { _checkMinSize=true; }
  inline void  Contact::disableCheckMinSize   () { _checkMinSize=false; }
  inline bool  Contact::isRotatedTopMetal     () const { return _flags & RotateTopMetal; }
  inline bool  Contact::isRotatedBottomMetal  () const { return _flags & RotateBottomMetal; }
 
  inline void  Contact::setRotatedTopMetal ( bool state )
  { if (state) _flags |= RotateTopMetal; else _flags &= ~RotateTopMetal; }
 
  inline void  Contact::setRotatedBottomMetal ( bool state )
  { if (state) _flags |= RotateBottomMetal; else _flags &= ~RotateBottomMetal; }
 
 
// -------------------------------------------------------------------
// Class  :  "Hurricane::JsonContact".
 
  class JsonContact : public JsonComponent {
    public:
      static void          initialize  ();
                           JsonContact ( unsigned long flags );
      virtual std::string  getTypeName () const;
      virtual JsonContact* clone       ( unsigned long ) const;
      virtual void         toData      ( JsonStack& ); 
  };
 
 
} // Hurricane namespace.
 
 
INSPECTOR_P_SUPPORT(Hurricane::Contact);
INSPECTOR_P_SUPPORT(Hurricane::Contact::AnchorHook);