---

/home/pauldt/projects/IDEA/IDEA-ALL/IDEA-DEV/Core/PlanServer/Includes/PslVariable.hh

Go to the documentation of this file.

// -*- Mode: c++ -*-
//     File: $Source: /home/cvs/ISG-Repository/IDEA-DEV/Core/PlanServer/Includes/PslVariable.hh,v $
//      Tag: $Name: DR_01_11_06 $
//      CVS: $Id: PslVariable.hh,v 1.16 2005/06/20 21:22:06 olvov Exp $
//     Info: $CVSROOT/Idea3/Copyright.txt
#ifndef PSL_VARIABLE_HEADER_
#define PSL_VARIABLE_HEADER_

#include "Utilities.hh"

#include "PslDataTypes.hh"
#include "PslVariableImpl.hh"

#include <set>
#include <algorithm>

namespace IDEA
{
  template <class Type>
  bool isTypeNumeric();

  class PslConstraint;
  class PslDatabase;
  class PslDomain;
  class PslObject;
  class PslObjectClass;
  class PslLabel;
  class PslLabelSet;

  class PslVariable
  {
    friend class PslDatabaseImpl;
  public:
    ~PslVariable();

    PslVariableImpl* getImpl() const;

    const PslDatabase* getDatabase() const;
    int getId() const;
    bool write( std::string& value ) const;
    bool read( const std::string& value ) const;
    void commit() const;
    const std::string getName() const;
    void print(std::ostream &) const;
    const PslDataType getDataType() const;
    bool isInterval() const;
    bool isEmpty() const;
    bool isDynamic() const;
    bool isSingleton() const;
    bool isEnumerated() const;
    bool isFinite() const;
    const PslConstraintList getConstraints() const;
    void removeConstraint( const PslConstraint* cnstr ) const;
    int getSize() const;
    template <class Type>
    Type getSingleton() const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );
      PSL_ASSERT( isSingleton(), PslSingletonNotSet );

      return m_Impl->getSingleton<Type>();
    }
    template <class Type>
    Type getMinimum() const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->getMinimum<Type>();
    }
    template <class Type>
    Type getMaximum() const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->getMaximum<Type>();
    }

    template <class Type>
    void setMinimum( Type v ) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->setMinimum<Type>( v );
    }

    template <class Type>
    void setMaximum( Type v ) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->setMaximum<Type>( v );
    }

    template <class Type>
    std::set<Type> getMembers() const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->getMembers<Type>();
    }
    template <class Type>
    bool hasMember(const Type val) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->hasMember<Type>(val);
    }
    bool hasIntersection( const PslVariable* variable ) const;
    void intersect( const PslVariable* other) const;
    template <class Type>
    void setToSingleton(Type newVal) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );
      
      m_Impl->setToSingleton(newVal);
    }
    template <class Type>
    void setToInterval(Type min, Type max) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      m_Impl->setToInterval<Type>(min, max);
    }
    template <class Type>
    void setMembers( const std::set<Type>& newSet ) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      m_Impl->setMembers<Type>(newSet);
    }
   template <class Type>
   void remove(Type val) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->remove<Type>(val);
    }
   template <class Type>
   const PslConstraint* constrainTo( Type val, int authority ) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->constrainTo<Type>(val, authority );
    }

   template <class Type>
   const PslConstraint* constrainToInterval( Type min, Type max, int authority ) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );

      return m_Impl->constrainToInterval<Type>( min, max, authority );
    }
    template <class Type>
    void insert( Type newVal ) const
    {
      PSL_ASSERT( m_Impl != 0, PslNoImpl );
      PSL_ASSERT( m_Impl->isDynamic(), PslConvention );

      m_Impl->insert<Type>(newVal);
    }
    void reset() const;

    bool conditionallyReset( const IntSet& authorities ) const;
    void setStatic() const;
  protected:
    PslVariableImpl* m_Impl;
  private:
    PslVariable( PslVariableImpl* impl );
    PslVariable( const PslDatabase* database, const PslDomain* domain, const std::string& name );
    PslVariable();
  };

  std::ostream & operator<<(std::ostream & os, const PslVariable& variable);
}

#endif // PSL_VARIABLE_HEADER_

---

Contact information © IDEA