#include <integer.h>

Inheritance diagram for operations_research::sat::IntegerDomains:

Additional Inherited Members
Public Types inherited from util_intops::StrongVector< PositiveOnlyIndex, Domain >
typedef std::vector< Domain, std::allocator< Domain > >	ParentType

typedef ParentType::size_type	size_type

typedef ParentType::allocator_type	allocator_type

typedef ParentType::value_type	value_type

typedef ParentType::reference	reference

typedef ParentType::const_reference	const_reference

typedef ParentType::pointer	pointer

typedef ParentType::const_pointer	const_pointer

typedef ParentType::iterator	iterator

typedef ParentType::const_iterator	const_iterator

typedef ParentType::reverse_iterator	reverse_iterator

typedef ParentType::const_reverse_iterator	const_reverse_iterator

Public Member Functions inherited from util_intops::StrongVector< PositiveOnlyIndex, Domain >
	StrongVector ()

	StrongVector (const allocator_type &a)

	StrongVector (size_type n)

	StrongVector (PositiveOnlyIndex n)

	StrongVector (size_type n, const value_type &v, const allocator_type &a=allocator_type())

	StrongVector (PositiveOnlyIndex n, const value_type &v, const allocator_type &a=allocator_type())

	StrongVector (const StrongVector &x)

	StrongVector (StrongVector &&x)=default

	StrongVector (std::initializer_list< value_type > l, const allocator_type &a=allocator_type())

	StrongVector (InputIteratorType first, InputIteratorType last, const allocator_type &a=allocator_type())

	~StrongVector ()

const ParentType &	get () const

ParentType *	mutable_get ()

reference	operator[] (PositiveOnlyIndex i)
	– Modified methods ----------------------------------------------------—

const_reference	operator[] (PositiveOnlyIndex i) const

reference	at (PositiveOnlyIndex i)

const_reference	at (PositiveOnlyIndex i) const

PositiveOnlyIndex	start_index () const
	– Extension methods ---------------------------------------------------—

PositiveOnlyIndex	end_index () const

bool	IsValidSize () const
	Returns true if the vector is fully addressable by the index type.

StrongIntRange< PositiveOnlyIndex >	index_range () const

value_type *	data ()
	– Pass-through methods to STL vector ----------------------------------—

const value_type *	data () const

StrongVector &	operator= (const StrongVector &x)

StrongVector &	operator= (StrongVector &&x)=default

StrongVector &	operator= (std::initializer_list< value_type > l)

void	swap (StrongVector &x) noexcept

void	assign (size_type n, const value_type &val)

void	assign (InputIt f, InputIt l)

void	assign (std::initializer_list< value_type > l)

iterator	emplace (const_iterator pos, Args &&... args)

reference	emplace_back (Args &&... args)

iterator	insert (const_iterator pos, const value_type &x)

iterator	insert (const_iterator pos, value_type &&x)

void	insert (const_iterator pos, size_type n, const value_type &x)

void	insert (const_iterator pos, SIT first, SIT last)

void	push_back (const value_type &val)

void	push_back (value_type &&val)

void	reserve (size_type n)

void	reserve (PositiveOnlyIndex n)

void	resize (size_type new_size)

void	resize (PositiveOnlyIndex new_size)

void	resize (size_type new_size, const value_type &x)

void	resize (PositiveOnlyIndex new_size, const value_type &x)

Detailed Description

A model singleton that holds the root level integer variable domains. we just store a single domain for both var and its negation.

Definition at line 375 of file integer.h.

The documentation for this struct was generated from the following file:

ortools/sat/integer.h

Additional Inherited Members

Detailed Description