# memberdef

refid: a29288365e2e26cbb2d23bb1c71dcfbb5
name: Algebra
definition: pelib::Algebra::Algebra
argsstring: (const std::map< std::string, const AlgebraData *const > &elements)
scope: pelib::Algebra
detaileddescription:
Creates a AMPL data container from Algebra elements found in the map collect given as argument. Note that the string element in each pair element in the collection must match the name of the corresponding AlgebraData data structure.  


refid: ac9d6588682815e8e684953e5fffc5c70
name: merge
definition: Algebra pelib::Algebra::merge
type: Algebra
argsstring: (const Algebra &) const
scope: pelib::Algebra
detaileddescription:
Builds a new collection from all elements in this collection and in the collection given as argument  


refid: a2e2f87d92b66dc3d7e2b87c0cb64f262
name: operator=
definition: Algebra & pelib::Algebra::operator=
type: Algebra &
argsstring: (const Algebra &rhs)
scope: pelib::Algebra
detaileddescription:
Flushes all elements in this collection, performs a copy of all elements found in the collection given as argument and place the copies in this collection  


refid: aae2d7e8f9dbc6c0a1d43c890f9e0e29e
name: convert
definition: static Target pelib::AlgebraDataParser::convert
type: Target
argsstring: (std::string element, bool strict=0)
scope: pelib::AlgebraDataParser
detaileddescription:
Converts a string into an instance of T and throws a ParseException upon conversion error. If T is a numeric base type (int, float and derivatives) and strict is true, then an attempt to convert a string that matches an integer value into a float or double results in throwing a NoDecimalException  


refid: ae7aa069110ec9f293b19fd0b9f673894
name: getDetailedPattern
definition: virtual std::string pelib::AlgebraDataParser::getDetailedPattern
type: std::string
argsstring: ()=0
scope: pelib::AlgebraDataParser
detaileddescription:
Returns a boost regular expression that extracts all data in the text to parse, that is stored in the corresponding data structure produced, such as its name or its values.  


refid: a523c8bc5a418bf96b40e8b9aeac0bea0
name: getGlobalPattern
definition: virtual std::string pelib::AlgebraDataParser::getGlobalPattern
type: std::string
argsstring: ()=0
scope: pelib::AlgebraDataParser
detaileddescription:
Returns a boost regular expression that matches the string representation of an algebraic data structure  


refid: ae54c97741aecd6337cf3991592ad3466
name: dump
definition: virtual void pelib::AlgebraOutput::dump
type: void
argsstring: (std::ostream &o, const Algebra &record) const =0
scope: pelib::AlgebraOutput
detaileddescription:
Generates some representation of an instance of Algebra through its reference and write it to output stream o.  


refid: a2facb379216a153da17fbc4f0b39f06f
name: dump
definition: virtual void pelib::AlgebraOutput::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const =0
scope: pelib::AlgebraOutput
detaileddescription:
Generates some representation of an instance of Algebra through its pointer and write it to output stream o.  


refid: af271b23f02013dff90aec03ae1740c51
name: AmplInput
definition: pelib::AmplInput::AmplInput
argsstring: (std::pair< std::vector< AmplInputDataParser * >, std::vector< AmplInputDataOutput * > > handlers)
scope: pelib::AmplInput
detaileddescription:
Creates a new instance of AmplInput parser and output. Parser and Output attempt to use all parsers and output classes until one produces output without throwing any instance of Parse- or Cast- exceptions.  


refid: ad173a440435cc927a4c3d10f0c611279
name: parse
definition: Algebra pelib::AmplInput::parse
type: Algebra
argsstring: (std::istream &data) const
scope: pelib::AmplInput
detaileddescription:
Parses AMPL input text from input stream and returns an instance of Algebra containing all data structure that could be parsed successfully, using parsers in the parser collection given when the class was instanciated. Parsing is performed in strict mode (See AlgebraDataParser). Any element that could not be parsed is parsed as Scalar, Vector, Matrix or Set of strings.  


refid: acbd163dec66119de76eb31e2845ae70e
name: dump
definition: void pelib::AmplInput::dump
type: void
argsstring: (std::ostream &o, const Algebra &record) const
scope: pelib::AmplInput
detaileddescription:
Outputs all elements in the given Algebra instance into output stream in output stream o in AmplInput format, using output classes given when the class was instanciated. Also output all string-based AlgebraData instances  


refid: a41fdf5ae5723424a22b2eef49ecc90aa
name: dump
definition: void pelib::AmplInput::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::AmplInput
detaileddescription:
Outputs an instance of AlgebraData instance into output stream in output stream o in AmplInput format, using output classes given when the class was instanciated. If no output could produce an output, uses a string-based output class  


refid: a27595d4cada45b5bb5f29094e1131080
name: operator=
definition: AmplInput & pelib::AmplInput::operator=
type: AmplInput &
argsstring: (const AmplInput &rhs)
scope: pelib::AmplInput
detaileddescription:
Copy constructor. Flushes all AmplInputData Parser and Output classes and copies the ones from the instance of AmplInput given as reference  


refid: aef9624c112bb627cd84d52c60d3b70e5
name: floatParsers
definition: std::vector< AmplInputDataParser * > pelib::AmplInput::floatParsers
type: std::vector< AmplInputDataParser * >
argsstring: ()
scope: pelib::AmplInput
detaileddescription:
Default AmplInput parsers to produce float derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes.  


refid: a7a7089ac27a210ec10a99f1787d016c0
name: floatOutputs
definition: std::vector< AmplInputDataOutput * > pelib::AmplInput::floatOutputs
type: std::vector< AmplInputDataOutput * >
argsstring: ()
scope: pelib::AmplInput
detaileddescription:
Default AmplInput outputs to output float derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes.  


refid: a927cd3fb3eb9e6e7d49d46fd09a50c6b
name: floatHandlers
type: std::pair< std::vector< AmplInputDataParser * >, std::vector< AmplInputDataOutput * > >
argsstring: ()
scope: pelib::AmplInput
definition:
std::pair< std::vector< AmplInputDataParser * >, std::vector< AmplInputDataOutput * > > pelib::AmplInput::floatHandlers

detaileddescription:
Default AmplInput parsers and outputs to produce and output float derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes.  


refid: a304851827981c9b6d2a74d2146731421
name: intFloatParsers
definition: std::vector< AmplInputDataParser * > pelib::AmplInput::intFloatParsers
type: std::vector< AmplInputDataParser * >
argsstring: ()
scope: pelib::AmplInput
detaileddescription:
Default AmplInput parsers to produce integer or float derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes.  


refid: ae0a4b05b65c8a7a2ebc6ac8ae4163d44
name: intFloatOutputs
definition: std::vector< AmplInputDataOutput * > pelib::AmplInput::intFloatOutputs
type: std::vector< AmplInputDataOutput * >
argsstring: ()
scope: pelib::AmplInput
detaileddescription:
Default AmplInput outputs to output integer or float derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes.  


refid: a93765fd97c8b35c1dd2afeff0fc9fd9a
name: intFloatHandlers
type: std::pair< std::vector< AmplInputDataParser * >, std::vector< AmplInputDataOutput * > >
argsstring: ()
scope: pelib::AmplInput
definition:
std::pair< std::vector< AmplInputDataParser * >, std::vector< AmplInputDataOutput * > > pelib::AmplInput::intFloatHandlers

detaileddescription:
Default AmplInput parsers and outputs to produce and output integer and float derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes.  


refid: a48dc19ee30c9139917c747dc7bd1f03c
name: stringParsers
definition: std::vector< AmplInputDataParser * > pelib::AmplInput::stringParsers
type: std::vector< AmplInputDataParser * >
argsstring: ()
scope: pelib::AmplInput
detaileddescription:
Default AmplInput parsers to produce string derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes. Used as last-resort parsers.  


refid: a3ecd416bf1299175145e254df27094c0
name: stringOutputs
definition: std::vector< AmplInputDataOutput * > pelib::AmplInput::stringOutputs
type: std::vector< AmplInputDataOutput * >
argsstring: ()
scope: pelib::AmplInput
detaileddescription:
Default AmplInput outputs to output string derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes. Used as last-resort outputs  


refid: aa872d59891dca752b81391b841b2c928
name: stringHandlers
type: std::pair< std::vector< AmplInputDataParser * >, std::vector< AmplInputDataOutput * > >
argsstring: ()
scope: pelib::AmplInput
definition:
std::pair< std::vector< AmplInputDataParser * >, std::vector< AmplInputDataOutput * > > pelib::AmplInput::stringHandlers

detaileddescription:
Default AmplInput parsers and outputs to produce and output float derivatives instances of AmplInputScalar, AmplInputVector, AmplInputMatrix and AmplInputSet classes. Used at last resort in parsing and output operations.  


refid: a068c66e20036765d11a0dca03cb9260a
name: strict
definition: bool pelib::AmplInputMatrix< Col, Row, Value >::strict
type: bool
scope: pelib::AmplInputMatrix< Col, Row, Value >
detaileddescription:
If true and parsing floating point matrix content, fails if any elment is an integer written without any trailing decimal part (e.g. 52.0)  


refid: aea62c310d95789f3c8138ddc8d8d2894
name: AmplInputMatrix
definition: pelib::AmplInputMatrix< Col, Row, Value >::AmplInputMatrix
argsstring: (bool strict=true)
scope: pelib::AmplInputMatrix< Col, Row, Value >
detaileddescription:
Constructor
    @param strict If parsing Floating-point values and any value to parse is an integer written with no decimal suffix (e.g. 52.0), then if strict is 1, then the complete parsin operation fails


refid: ab0fdf81fbc06e840698ffcbf74df7f73
name: getDetailedPattern
definition: virtual std::string pelib::AmplInputMatrix< Col, Row, Value >::getDetailedPattern
type: std::string
argsstring: ()
scope: pelib::AmplInputMatrix< Col, Row, Value >
detaileddescription:
Returns a boost::regex pattern that can match a matrix in AMPL output format and capture each of its elements  


refid: aa1b022a84cead62c3e7fb57048cd7452
name: parse
definition: virtual AlgebraData* pelib::AmplInputMatrix< Col, Row, Value >::parse
type: AlgebraData *
argsstring: (std::istream &in)
scope: pelib::AmplInputMatrix< Col, Row, Value >
detaileddescription:
Parses in content of input stream in AMPL Input format into an instance of pelib::Matrix
    @param in Text input stream in AMPL input data format to parse into a matrix
    @return An instance of pelib::Matrix with the content parsed.


refid: aff5830d46eba183fa7d57e39b3e550d8
name: dump
definition: virtual void pelib::AmplInputMatrix< Col, Row, Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::AmplInputMatrix< Col, Row, Value >
detaileddescription:
Writes the content in class instance of pelib::Matrix into text output stream in AMPL input data format
    @param o Output stream where the matrix is written to in AMPL input data format
    @param data Instance of pelib::Matrix to be written in output stream


refid: ab01e55dd54e9e74c60052f3d9b9e8f26
name: AmplInputScalar
definition: pelib::AmplInputScalar< Value >::AmplInputScalar
argsstring: (bool strict=true)
scope: pelib::AmplInputScalar< Value >
detaileddescription:
Constructor
    @param strict If true and parsing floating point values, fails when reading any integer value if not written with a trailing decimal 0, e.g. 52.0


refid: ac78dad7036989267c71e497f1a45661a
name: parse
definition: virtual AlgebraData* pelib::AmplInputScalar< Value >::parse
type: AlgebraData *
argsstring: (std::istream &in)
scope: pelib::AmplInputScalar< Value >
detaileddescription:
Parse input stream in AMPL input format and builds an instance of a derivative class of pelib::AlgebraData containing the values read  


refid: a52150125b6ecc843b92f5ce862faeb6d
name: dump
definition: virtual void pelib::AmplInputScalar< Value >::dump
type: void
argsstring: (std::ostream &stream, const AlgebraData *data) const
scope: pelib::AmplInputScalar< Value >
detaileddescription:
Writes an instance of class that derives from pelib::AlgebraData to output stream
    @param stream Output stream that receives the written output of AlgebraData
    @param data Instance of a class derived from AlgebraData to write to output stream


refid: ac8fbc3ca0f5e2c1320faed62a7ede43a
name: SetType
type: std::set< Value, std::less< Value >, std::allocator< Value > >
scope: pelib::AmplInputSet< Value >
detaileddescription: Type of the set data manipulated in member functions
definition:
typedef std::set<Value, std::less<Value>, std::allocator<Value> > pelib::AmplInputSet< Value >::SetType


refid: a74f10dc4255e7e6e33cb0425646f895b
name: strict
definition: bool pelib::AmplInputSet< Value >::strict
type: bool
scope: pelib::AmplInputSet< Value >
detaileddescription:
Defines if parsin operation should fail upon the parsing of an integer when the Set holds floating-point numeric values  


refid: a039854170b6003b223f0a638fae46d83
name: AmplInputSet
definition: pelib::AmplInputSet< Value >::AmplInputSet
argsstring: (bool strict=true)
scope: pelib::AmplInputSet< Value >
detaileddescription:
Constructor
    @param strict If true and Value is a floating-point numeric type, fails if one element is an integer. An integer written as a float (e.g. 52.0) doesn't make the parser to fail


refid: a0f49608716551ba483d0a2f3e20462e6
name: parse
definition: virtual AlgebraData* pelib::AmplInputSet< Value >::parse
type: AlgebraData *
argsstring: (std::istream &in)
scope: pelib::AmplInputSet< Value >
detaileddescription:
Parse input stream in AMPL input data format into a pointer to an instance of pelib::Set
    @param in Input stream in AMPL input data format to be parsed
    @return An instance of pelib::Set holding all values parsed from in  


refid: a1f9384c34fc67ced64e7153d99ba4d03
name: dump
definition: virtual void pelib::AmplInputSet< Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::AmplInputSet< Value >
detaileddescription:
Output all values of instance of pelib::set into output stream in AMPL input data format
    @param o Output stream to write to in AMPL input data format
    @param data Instance of pelib::Set whose values are to be written to output stream


refid: aa93c25f7788d7979e78733bbf14d0b82
name: getDetailedPattern
definition: virtual std::string pelib::AmplInputSet< Value >::getDetailedPattern
type: std::string
argsstring: ()
scope: pelib::AmplInputSet< Value >
detaileddescription:
Returns a boost::regex regular expression that matches a Set in AMPL input data format and able to extract its elements  


refid: ab88137a5ddbbb1a1141be6624c345153
name: AmplInputVector
definition: pelib::AmplInputVector< Key, Value >::AmplInputVector
argsstring: (bool strict=true)
scope: pelib::AmplInputVector< Key, Value >
detaileddescription:
Constructor
@param strict if Value is a floating-point number, fails if any element parsed is an integer (but succeeds if it is written as a float, i.e., 52.0


refid: af544a7f4a98c6f19ce1a1621d514b656
name: parse
definition: virtual AlgebraData* pelib::AmplInputVector< Key, Value >::parse
type: AlgebraData *
argsstring: (std::istream &in)
scope: pelib::AmplInputVector< Key, Value >
detaileddescription:
Parses the input stream into a instance of Pelib::Vector
    @param in input stream in AMPL input data format to be parsed


refid: a2ee0b399f081e8e1d239702940d85ad9
name: dump
definition: virtual void pelib::AmplInputVector< Key, Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::AmplInputVector< Key, Value >
detaileddescription:
Dumps the content of a pelib::Vector into an output stream in AMPL input data format
    @param o Output stream where is written the vector in AMPL input data format
    @param data pelib::Vector to be written to output stream


refid: a613ec75b055acb171eb62cea9a24aec1
name: getDetailedPattern
definition: virtual std::string pelib::AmplInputVector< Key, Value >::getDetailedPattern
type: std::string
argsstring: ()
scope: pelib::AmplInputVector< Key, Value >
detaileddescription:
Returns a boost::regex regular expression that matches a AMPL input data vector data structure and can extract all its elements  


refid: a898b9d869dac5abdf8e9efb02fa3f2e4
name: AmplOutput
definition: pelib::AmplOutput::AmplOutput
scope: pelib::AmplOutput
argsstring:
(std::pair< std::vector< AmplOutputDataParser * >, std::vector< AmplOutputDataOutput * > > handlers)

detaileddescription:
Constructor
    @param handlers A pair of collections of Algebraic Data parsers and Output. May include parsers and output for scalars, vector, set or matrices for int, float, double or any other basic type.


refid: a4c8b1438de983fac925d9fde52de5c5b
name: parse
definition: Algebra pelib::AmplOutput::parse
type: Algebra
argsstring: (std::istream &data) const
scope: pelib::AmplOutput
detaileddescription:
Reads input stream and produces a collection of pelib::AlgebraData derived class instances such as Scalar, Vector, Set and Matrix. Warning, this can be a ver slow process with large inputs  


refid: a74b5c07b3fe04396d3776741acb8eecd
name: dump
definition: void pelib::AmplOutput::dump
type: void
argsstring: (std::ostream &o, const Algebra &record) const
scope: pelib::AmplOutput
detaileddescription:
Writes all derived instance of pelib::AlgebraData in the container to output stream in AMPL output text format  


refid: aa91a2d531a842381f553376933eba31e
name: floatHandlers
type: std::pair< std::vector< AmplOutputDataParser * >, std::vector< AmplOutputDataOutput * > >
argsstring: ()
scope: pelib::AmplOutput
detaileddescription: Returns parsers and output specialized into floating-point content
definition:
std::pair< std::vector< AmplOutputDataParser * >, std::vector< AmplOutputDataOutput * > > pelib::AmplOutput::floatHandlers


refid: a2fb36c07cc59aeb7941bd978d1294f7b
name: intFloatHandlers
type: std::pair< std::vector< AmplOutputDataParser * >, std::vector< AmplOutputDataOutput * > >
argsstring: ()
scope: pelib::AmplOutput
detaileddescription: Returns parsers and output specialized into integer and floating-point content
definition:
std::pair< std::vector< AmplOutputDataParser * >, std::vector< AmplOutputDataOutput * > > pelib::AmplOutput::intFloatHandlers


refid: adddc6c79ba22e0bf21ee4991dadbf6c4
name: stringHandlers
type: std::pair< std::vector< AmplOutputDataParser * >, std::vector< AmplOutputDataOutput * > >
argsstring: ()
scope: pelib::AmplOutput
detaileddescription: Returns parsers and outputs specialized into string content
definition:
std::pair< std::vector< AmplOutputDataParser * >, std::vector< AmplOutputDataOutput * > > pelib::AmplOutput::stringHandlers


refid: affefc95d30a68d5bd56f4fa1e1cdd917
name: AmplOutputMatrix
definition: pelib::AmplOutputMatrix< Col, Row, Value >::AmplOutputMatrix
argsstring: (bool strict=true)
scope: pelib::AmplOutputMatrix< Col, Row, Value >
detaileddescription:
Constructor
    @param strict if 1 and parsing a matrix of floating-points values (except indexes), fails if any value parsed is an integer. An integer written as a float (e.g. 52.0) doesn't makes the parser to fail


refid: aafa176fb2a8d97b3ad4b43143b04f515
name: getDetailedPattern
definition: virtual std::string pelib::AmplOutputMatrix< Col, Row, Value >::getDetailedPattern
type: std::string
argsstring: ()
scope: pelib::AmplOutputMatrix< Col, Row, Value >
detaileddescription:
Returns a string boost::regex regular expression able to match a Matrix in AMPL output format and extract its name, indexes and values to an instance of pelib::Matrix  


refid: a62d2ae1fa773e62daf8085200d7c0ef2
name: parse
definition: virtual AlgebraData* pelib::AmplOutputMatrix< Col, Row, Value >::parse
type: AlgebraData *
argsstring: (std::istream &in)
scope: pelib::AmplOutputMatrix< Col, Row, Value >
detaileddescription:
Reads the content of an input stream in AMPL output text format and builds an instance of pelib::Matrix from all values read  


refid: aa10015d6fa3635beb269519dda27ffdf
name: AmplOutputScalar
definition: pelib::AmplOutputScalar< Value >::AmplOutputScalar
argsstring: (bool strict=true)
scope: pelib::AmplOutputScalar< Value >
detaileddescription:
Constuctor
    @param strict If true and parsing floating point values, fails in any element parsed is an integer. An integer written as a float (e.g. 52.0) doesn't make the parser to fail.


refid: a899e909bee76f013a6913de21caa1b23
name: getDetailedPattern
definition: virtual std::string pelib::AmplOutputScalar< Value >::getDetailedPattern
type: std::string
argsstring: ()
scope: pelib::AmplOutputScalar< Value >
detaileddescription:
Returns a boost::regex string able to match a scalar in AMPL output format and extract its name and value  


refid: ad7a20d2683220ac7f3b42d6d3f62979f
name: SetType
type: std::set< Value, std::less< Value >, std::allocator< Value > >
scope: pelib::AmplOutputSet< Value >
definition:
typedef std::set<Value, std::less<Value>, std::allocator<Value> > pelib::AmplOutputSet< Value >::SetType


refid: ab30653230b2eb1be04ec7116b05cf45b
name: AmplOutputSet
definition: pelib::AmplOutputSet< Value >::AmplOutputSet
argsstring: (bool strict=true)
scope: pelib::AmplOutputSet< Value >
detaileddescription:
Constructor
    @param strict If elements in Set are floating-point numeric values and strict is true, then parser fails if any element parsed is written as an integer. A trailing .0 (e.g. 52.0) can force an integer to be parsed as floating-point without failure.


refid: a0e26a54e1951dec7177c4a9b8c262c9e
name: getDetailedPattern
definition: virtual std::string pelib::AmplOutputSet< Value >::getDetailedPattern
type: std::string
argsstring: ()
scope: pelib::AmplOutputSet< Value >
detaileddescription:
Returns a boost::regex regular expression able to match a AMPL output format Set and extract its elements  


refid: a3198f212d7c377d3b4c2ee7f24023ccc
name: parse
definition: virtual AlgebraData* pelib::AmplOutputSet< Value >::parse
type: AlgebraData *
argsstring: (std::istream &in)
scope: pelib::AmplOutputSet< Value >
detaileddescription:
Parses input stream in AMPL output format and builds an instance of pelib::Set from the data extracted
    @param in input stream to read data from


refid: a6b52019fee8df089f4768a1280631667
name: dump
definition: virtual void pelib::AmplOutputSet< Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::AmplOutputSet< Value >
detaileddescription:
Write the content of an instance of pelib::Set into output stream in AMPL output format
    @param o Output stream where the set is written to in AMPL output format
    @param data Instance of pelib::Set to write to output stream


refid: ab274a750e39e36de8fddbee658c7895e
name: AmplOutputVector
definition: pelib::AmplOutputVector< Key, Value >::AmplOutputVector
argsstring: (bool strict=true)
scope: pelib::AmplOutputVector< Key, Value >
detaileddescription:
Constructor
    @param strict If true and parsing a floating-point values-collection, fails if any element is an integer but succeeds if integers are written with a trailing decimal 0 (e.g. 52.0)


refid: a8a872fdca146eb8f3cedcfe5244a5997
name: getDetailedPattern
definition: virtual std::string pelib::AmplOutputVector< Key, Value >::getDetailedPattern
type: std::string
argsstring: ()
scope: pelib::AmplOutputVector< Key, Value >
detaileddescription:
Uses a boost::regex regular expression to match a vector written in AMPL output format and extract its name and value  


refid: afac69689de1b3e50e58a090d6e272149
name: parse
definition: virtual AlgebraData* pelib::AmplOutputVector< Key, Value >::parse
type: AlgebraData *
argsstring: (std::istream &in)
scope: pelib::AmplOutputVector< Key, Value >
detaileddescription:
Reads input stream in AMPL output format and builds an instance of pelib::Vector containing all values
    @param in Input stream to read AMPL output text from
    @return An instance of pelib::Vector containing all values read from input


refid: a73ce9215078e2e5f0b599355eb871b75
name: dump
definition: virtual void pelib::AmplOutputVector< Key, Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::AmplOutputVector< Key, Value >
detaileddescription:
Writes an instance of pelib::Vector into an output stream in AMPL output format
    @param o Output stream
    @param data Instance of pelib::Vector to be written


refid: abf8f15858edd6b8ea807d31f877b176d
name: dump
definition: void pelib::Cpp::dump
type: void
argsstring: (std::ostream &o, const Algebra &record) const
scope: pelib::Cpp
detaileddescription:
Generates C++ code that instanciates all AlgebraData instances in a given Algebra collection, to some C++ function code and writes it in output stream  


refid: a718fe458173dca9b266cfb133d677e08
name: operator=
definition: Cpp & pelib::Cpp::operator=
type: Cpp &
argsstring: (const Cpp &rhs)
scope: pelib::Cpp
detaileddescription:
Assignment operator. Flushes all output classes contained before receiving the ones from the Cpp output class assigned  


refid: a9961ab7edb833404733aa3c131ddfa94
name: type_name
definition: const std::string pelib::CppData::type_name
type: const std::string
argsstring: (const std::type_info &type) const
scope: pelib::CppData
detaileddescription:
Returns the C++ type string to use in a C/C++ source code, associated to a C++ type
    @param type Type of some C++ object obtained thanks to typeid()


refid: ac218c7a2eee14057e93f6f00cefda3ed
name: dump
definition: virtual void pelib::CppMatrix< Col, Row, Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::CppMatrix< Col, Row, Value >
detaileddescription:
Generates C++ code that instanciates and instance of pelib::Matrix and fills it with all values contained in the Matrix given as parameter
    @param o Output stream where C++ code is written to
    @param data Instance of pelib::Matrix that is written to output stream as C++ code


refid: a2abe9b44c1e14c3d29ba023905a54102
name: dump
definition: virtual void pelib::CppScalar< Value >::dump
type: void
argsstring: (std::ostream &stream, const AlgebraData *data) const
scope: pelib::CppScalar< Value >
detaileddescription:
Generate and write C++ code to output stream, that produces an instance of pelib::Scalar that holds the data in instance of pelib::Scalar given as argument
    @param stream Output stream where the generated C++ code is written to
    @param data Instance of pelib::Scalar that contains the scalar to be written


refid: ae33b5a23338e9b3605ac957271278086
name: dump
definition: virtual void pelib::CppSet< Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::CppSet< Value >
detaileddescription:
Generate C++ code that declares a C++ set instance and fills it with the data given in the pelib::Set object instance passed  


refid: afb76fad29e7b9b9288a2522bec95b10c
name: dump
definition: virtual void pelib::CppVector< Key, Value >::dump
type: void
argsstring: (std::ostream &o, const AlgebraData *data) const
scope: pelib::CppVector< Key, Value >
detaileddescription:
Generates C++ code that produce the same instance of pelib::Vector as given as parameter and writes it to output stream
    @param o Output stream that receives the generated C++ code
    @param data Instance of pelib::Vector that is translated to C++ code


refid: a17d8d565284a2661a1fb5a66fa48058c
name: getDeadlineCalculator
definition: DeadlineCalculator * pelib::DeadlineCalculator::getDeadlineCalculator
type: DeadlineCalculator *
argsstring: (const std::string key)
scope: pelib::DeadlineCalculator
detaileddescription:
Return an instance derived from DeadlineCalculator that can compute a deadline from a string formula
    @param key Formula used by a suitable derived class of DeadlineCalculator to compute a deadline


refid: a55a1809e011927ddd25d03b8ae326272
name: value
definition: const double pelib::DeadlineConstant::value
type: const double
scope: pelib::DeadlineConstant
detaileddescription:
Holds the value given when the class instance was constructed and returned upon calls to calculate()  


refid: a22fe09252bb381953c981073230eb61d
name: DeadlineConstant
definition: DeadlineConstant::DeadlineConstant
argsstring: (double val)
scope: pelib::DeadlineConstant
detaileddescription:
Constructor: holds the floating-point value given as parameter to return it upon invocation of calculate()  


refid: a713e1a099445b591734236f43ca56050
name: calculate
definition: double DeadlineFormula::calculate
type: double
argsstring: (const Taskgraph &tg, const Platform &arch) const
scope: pelib::DeadlineFormula
detaileddescription:
Interpret and computes a deadline given instances of a Taskgraph and of a Platform
    @param tg Taskgraph containing the tasks to run withing the deadline to compure
    @param arch Platform that runs the tasks


refid: a3ca2f796de485761396d78b973a410bf
name: dump
definition: virtual void pelib::DrakeCSchedule::dump
type: void
argsstring: (std::ostream &os, const Schedule *data, const Taskgraph *tg, const Platform *pt) const
scope: pelib::DrakeCSchedule
detaileddescription:
Generate C code to output stream, that holds all Taskgraph, Platform and Schedule information required for a drake application
    @param os Output stream where generated C code is written
    @param data Schedule of the Drake application
    @param tg Taskgraph of the application
    @param pt Platform description for which the Drake application is scheduled for


refid: ac1eb671498366758e1608d62f4deed3e
name: parse
definition: Taskgraph * GraphML::parse
type: Taskgraph *
argsstring: (std::istream &is) const
scope: pelib::GraphML
detaileddescription:
Produces and instance of Taskgraph by parsing text input stream in GraphML format
    @return is Input text stream in GraphML format


refid: a6ed38c5c06facd4919e27a78720a3db1
name: dump
definition: virtual void pelib::GraphML::dump
type: void
argsstring: (std::ostream &str, const Taskgraph *data) const
scope: pelib::GraphML
detaileddescription:
Output an instance of pelib::Taskgraph to text output stream in GraphML format
    @param str output stream to write GraphML taskgraph to
    @param data Instance of pelib::Taskgraph to be written in output stream


refid: a760bcfd62ce91e9d03160ff60fddf73f
name: dump
definition: virtual void pelib::GraphML::dump
type: void
argsstring: (std::ostream &os, const Taskgraph &data, const Platform &arch) const
scope: pelib::GraphML
detaileddescription:
Output an instance of pelib::Taskgraph to text output stream in GraphML format with formula interpreted to fit an execution platform
    @param str output stream to write GraphML taskgraph to
    @param data Instance of pelib::Taskgraph to be written in output stream
    @param arch Instance of pelib::Platform to parse deadline and efficiency formulas in Taskgraph description


refid: aa990ab1e267752893153b6ecbfd80ee5
name: operator<
definition: bool pelib::Link::operator<
type: bool
argsstring: (const Link &other) const
scope: pelib::Link
detaileddescription:
Check if this link is striclty inferior to another link given 
    @param other Other link to compare this instance to


refid: a16b999a4e18df31cf55e531983dcd337
name: operator==
definition: bool pelib::Link::operator==
type: bool
argsstring: (const Link &other) const
scope: pelib::Link
detaileddescription:
Returns true if this instance is considered equivalent to another link
    @param other Other link to be compared


refid: ac45e64ba9d356d7e6b01b2290a7c8b18
name: NoDecimalFloatException
definition: pelib::NoDecimalFloatException::NoDecimalFloatException
argsstring: (std::string message, float value)
scope: pelib::NoDecimalFloatException
detaileddescription:
Constructor
    @param message Human-readable message that explains the error
    @param floating point value parsed


refid: a5ade8bda67fdef62c06e0e86a10eb622
name: ParseException
definition: pelib::ParseException::ParseException
argsstring: (const std::string &msg)
scope: pelib::ParseException
detaileddescription:
Consutrctor
    @param msg Human-readable explicative message that describes teh reason why this class instance was thrown


refid: ae31fc31986080945d2ac2fa75cadb329
name: argv
definition: char** pelib_argument_stream::argv
type: char **
scope: pelib_argument_stream
detaileddescription:
Filename of the library that holds the code able to perform the input or output operation. If a path is not provided, checks in pelib-convert built-in search path (defined as the LD_RUN_PATH environmnet variable at the time pelib-convert was built) or LD_LIBRARY_PATH environment variable, if defined (see document of ld for more information). If not a filename, look for the dynamic library "libpelib-" + library + ".so" in search path as described above  


refid: a24f2ef4d14c22df29dd2691e8aa76857
name: stream
definition: enum stream pelib_argument_stream::stream
type: enum stream
scope: pelib_argument_stream
detaileddescription:
If reading input, associates a custom name to the content parse, instead of the class name of the content parsed.  


refid: ab042304b50afe09eb88dd4509f16ee95
name: Platform
definition: pelib::Platform::Platform
argsstring: (size_t p, const Core *ref)
scope: pelib::Platform
detaileddescription:
Constructor
    @param p Number of cores in this platform. Each core is its own shared memory, main memory, private memory, voltage and frequency island
    @param ref Pointer to an instance of pelib::Core duplicated p times and stored in the Platform instance being build


refid: a5e55ece2124f1c4e7b44fdf9f43289c4
name: Platform
definition: pelib::Platform::Platform
argsstring: (const std::set< const Core * > &cores)
scope: pelib::Platform
detaileddescription:
Constructor
    @param cores Collection of derivative instances of pelib::Core that model all execution cores in the platform. Each core is its own shared memory, main memory, private memory, voltage and frequency island


refid: a85514c3794b419574a4bede516691d64
name: Platform
definition: pelib::Platform::Platform
scope: pelib::Platform
argsstring:
(const std::set< const Core * > &cores, const std::set< std::set< const Core * > > &shared, const std::set< std::set< const Core * > > &main, const std::set< std::set< const Core * > > &priv, const std::set< std::set< const Core * > > &voltage, const std::set< std::set< const Core * > > &freq)

detaileddescription:
Constructor
    @param cores Collection of derivative instances of pelib::Core that model all execution cores in the platform. Each core is its own shared memory, main memory, private memory, voltage and frequency island
    @param shared On-chip shared memory islands
    @param main Off-chip shared memory islands
    @param priv Off-chip Private memory islands
    @param voltage Voltage scaling islands
    @param freq Frequency scaling islands


refid: a1196eb2fe66e186958d2f26262a43c66
name: Platform
definition: pelib::Platform::Platform
argsstring: (const Algebra &arch)
scope: pelib::Platform
detaileddescription:
Constructor
    @param arch Algebraic representation of a platform: Scalar p is the number of cores, set F is the set of frequency each core can run at. Each core is its own shared memory, main memory, private memory, voltage and frequency island


refid: a999e38f16f4dbed175d3ed91bec58264
name: getSharedMemoryIslands
definition: const std::set< Platform::island > pelib::Platform::getSharedMemoryIslands
type: const std::set< island >
argsstring: (size_t core_id) const
scope: pelib::Platform
detaileddescription:
Returns the shared memory island corresponding to the core_id-th core of the platform, starting with 1  


refid: ae4e03b75fa16f28e9fa760da30f16894
name: getSharedMemoryIslands
definition: const std::set< Platform::island > pelib::Platform::getSharedMemoryIslands
type: const std::set< island >
argsstring: (const std::set< int > &islands) const
scope: pelib::Platform
detaileddescription:
Returns the shared memory islands a set of cores belongs to
    @param islands Set of core id the shared memory islands' are requested


refid: abafe1d944ee05a8ecb50be3d60d97d44
name: getSharedMemoryIslands
definition: virtual const std::set<int> pelib::Platform::getSharedMemoryIslands
type: const std::set< int >
argsstring: (const std::set< island > &islands) const
scope: pelib::Platform
detaileddescription:
Returns the core ids contained in a shared memory island
    @param islands Shared memory islands that contains the cores to be returned


refid: a5cf856cfd8038d837421e4015e80785b
name: getMainMemoryIslands
definition: const std::set< Platform::island > pelib::Platform::getMainMemoryIslands
type: const std::set< island >
argsstring: (size_t core_id) const
scope: pelib::Platform
detaileddescription:
Returns the main memory island corresponding to the core_id-th core of the platform, starting with 1  


refid: a35dc675e1354142784550f26a40bffff
name: getPrivateMemoryIslands
definition: const std::set< Platform::island > pelib::Platform::getPrivateMemoryIslands
type: const std::set< island >
argsstring: (size_t core_id) const
scope: pelib::Platform
detaileddescription:
Returns the private memory island corresponding to the core_id-th core of the platform, starting with 1  


refid: a3b6984a139a3e8492f9044731011c1bd
name: getVoltageIsland
definition: const Platform::island & pelib::Platform::getVoltageIsland
type: const island &
argsstring: (size_t core_id) const
scope: pelib::Platform
detaileddescription:
Returns the voltage memory island corresponding to the core_id-th core of the platform, starting with 1  


refid: a8f3437b5e5b14126b579e27ea167c185
name: getFrequencyIsland
definition: const Platform::island & pelib::Platform::getFrequencyIsland
type: const island &
argsstring: (size_t core_id) const
scope: pelib::Platform
detaileddescription:
Returns the frequency memory island corresponding to the core_id-th core of the platform, starting with 1  


refid: ae2d13482e1d724a16aecc2308fb65e4e
name: getCoreId
definition: size_t pelib::Platform::getCoreId
type: size_t
argsstring: (const Core *) const
scope: pelib::Platform
detaileddescription:
Returns the core id in the platform that corresponds to a pointer to core; throws a CastException if the core doesn't belong to this plaform  


refid: a1603fc75b010cae4e4d3386849fbcdac
name: buildAlgebra
definition: Algebra pelib::Platform::buildAlgebra
type: Algebra
argsstring: () const
scope: pelib::Platform
detaileddescription:
Builds an algebraic representation of this platform: p is the number of cores and F is the set of frequency they can run at  


refid: a35b9c660a69f5f386e6c6c4b0c61d045
name: dump
definition: virtual void pelib::PlatformOutput::dump
type: void
argsstring: (std::ostream &o, const Record *data) const =0
scope: pelib::PlatformOutput
detaileddescription:
Writes the platform in output stream
    @param o Output stream to write Platform instance to
    @param data Instance of pelib::Platform to be written to output stream


refid: aee246b3c9ebb07a63aad18a91de3dabf
name: do_nothing
definition: virtual void pelib::Record::do_nothing
type: void
argsstring: ()
scope: pelib::Record
detaileddescription:
    For some interesting reason, a pointer to Record pointing to a derived class is resolved as a Record by typeinfo if there is no virtual function in the base class.
This is an empty virtual function to make sure type_info can resolve the right class name


refid: a7e267f3f86584f7587d95c58fa3cc831
name: Schedule
definition: pelib::Schedule::Schedule
argsstring: (const std::string &name, const std::string &appName, const table &schedule)
scope: pelib::Schedule
detaileddescription:
Constructor
    @param name name of the schedule. This is only for human-redability purpose
    @param appName name of the application this schedule is designed for
    @param schedule collection of task sequences to run by each processor in the schedule


refid: a90c58af9e8c304cd21313794dff1440e
name: Schedule
definition: pelib::Schedule::Schedule
argsstring: (const std::string &name, const Algebra &algebra)
scope: pelib::Schedule
detaileddescription:
Constructor 
    @param algebra Collection of AlgebraData descendant class instances that describes a schedule in an algebraic form, used as basis to build the Schedule class instance


refid: af39bcaf3ce0f73124afa6b67e9d52d8a
name: getTasks
definition: const set< const Task * > & pelib::Schedule::getTasks
type: const set< const Task * > &
argsstring: (int core) const
scope: pelib::Schedule
detaileddescription:
Returns the set of tasks run by a core identified by its number
    @param core Core number, starting from 1


refid: ab91199a6956302b38a730f16adc75c1a
name: getTask
definition: const Task & pelib::Schedule::getTask
type: const Task &
argsstring: (int id) const
scope: pelib::Schedule
detaileddescription:
Returns the ith task in the Schedule tasks collection
    @param id Index of the task, starting from 1, to be read from the Schedule's internal collection of Task


refid: a51310559fd796ae2260976c3ad4da792
name: getTasksSharedMemoryIsland
definition: set< const Task * > pelib::Schedule::getTasksSharedMemoryIsland
type: set< const Task * >
argsstring: (const set< int > &islands, const Platform &pt) const
scope: pelib::Schedule
detaileddescription:
Returns the tasks contained in a shared memory island, identified by the set of cores that forms this island.
    @param islands Set of core id (starting from 1) that form a shared memory island 
    @param pt Execution platform that corresponds to this schedule


refid: a495d5e68a589b7384b79a6e30a815e7e
name: getRemoteSharedMemoryIslandProducers
definition: multiset< const Task * > pelib::Schedule::getRemoteSharedMemoryIslandProducers
type: multiset< const Task * >
argsstring: (const set< int > &islands, const Taskgraph &tg, const Platform &pt) const
scope: pelib::Schedule
detaileddescription:
Returns the set of Task that are mapped to other shared memory islands than the island collection given as parameter, and produce data consumed by tasks mapped in the set of islands given as parameters
    @param islands Set of islands
    @param tg Taskgraph that describe links between tasks
    @param pt Platform description that defines shared memory islands


refid: a624eefc4f8c2975d3d5ce86e3c29f0f7
name: getRemoteSharedMemoryIslandTaskProducers
definition: multiset< const Task * > pelib::Schedule::getRemoteSharedMemoryIslandTaskProducers
type: multiset< const Task * >
argsstring: (const Task &t, const Taskgraph &tg, const Platform &pt) const
scope: pelib::Schedule
detaileddescription:
Returns the set of Task that are mapped to another shared memory island than Task t, and produce data that Task t consumes
    @param t Task for which this function computes the set of remote tasks that produce data for it.
    @param tg Taskgraph that defines the links between tasks
    @param pt Platform that defines the core shared memory islands


refid: a677ced302e568aa2a768848479112c40
name: getRemoteSharedMemoryIslandConsumers
definition: multiset< const Task * > pelib::Schedule::getRemoteSharedMemoryIslandConsumers
type: multiset< const Task * >
argsstring: (const set< int > &islands, const Taskgraph &tg, const Platform &pt) const
scope: pelib::Schedule
detaileddescription:
Returns the set of Task that are mapped to other shared memory islands than the island collection given as parameter, and consume data produced by tasks mapped in the set of islands given as parameters
    @param islands Set of islands
    @param tg Taskgraph that describe links between tasks
    @param pt Platform description that defines shared memory islands


refid: a70f73e7e0d88f331cf06efc39cef59ea
name: getRemoteSharedMemoryIslandTaskConsumers
definition: multiset< const Task * > pelib::Schedule::getRemoteSharedMemoryIslandTaskConsumers
type: multiset< const Task * >
argsstring: (const Task &t, const Taskgraph &tg, const Platform &pt) const
scope: pelib::Schedule
detaileddescription:
Returns the set of Task that are mapped to another shared memory island than Task t, and consume data that Task t produces
    @param t Task for which this function computes the set of remote tasks that consume data from it
    @param tg Taskgraph that defines the links between tasks
    @param pt Platform that defines the core shared memory islands


refid: af26a1bca8e3b1e0937ecb198438497eb
name: getCores
definition: const set< int > pelib::Schedule::getCores
type: const set< int >
argsstring: (const Task &t) const
scope: pelib::Schedule
detaileddescription:
Returns the set of cores that execute a Task
    @param t Task that is run by the set of cores returned by the function


refid: ae3a21eb8062b217a57322e22fbc75adb
name: addStartTime
definition: Algebra pelib::Schedule::addStartTime
type: Algebra
argsstring: (const Algebra &data, const Taskgraph &tg, const Platform &platform)
scope: pelib::Schedule
detaileddescription:
Computes the starting time of each task in a schedule and add this starting time to a copy of the algebraic form schedule
    @param data Schedule in algebraic form that lacks the starting time of tasks
    @param tg Taskgraph that contains extended information about tasks
    @param platform Platform description that matches the algebraic schedule


refid: a3d1f05503f72d7c8a228a3551fa2e86c
name: setSchedule
definition: void pelib::Schedule::setSchedule
type: void
argsstring: (const table &)
scope: pelib::Schedule
detaileddescription:
Set the schedule of this class instance from a collection of task sequences. This method duplicates the tasks so the Schedule instance owns all instances of Tasks that the schedule refers to


refid: ae807b93e0f649f0859b96f0b2d8d62f6
name: dump
definition: virtual void pelib::ScheduleOutput::dump
type: void
argsstring: (std::ostream &os, const Schedule *data, const Taskgraph *tg, const Platform *pt) const =0
scope: pelib::ScheduleOutput
detaileddescription:
Writes a schedule into output stream with support from associated taskgraph and execution platform, depending on details required
    @param os Output stream where the schedule is written
    @param data Instance of pelib::Schedule to be written in output stream
    @param tg Additional data from the taskgraph associated to this schedule
    @parame pt Additional data from the platform associated to this schedule


refid: a9227e3d3044001cb148caa931969d931
name: getEfficiency
definition: double pelib::Task::getEfficiency
type: double
argsstring: (int p, double def=very_small) const
scope: pelib::Task
detaileddescription:
Computes the efficiency of the task, given its efficiency formula
    @param p Get efficiency of the task for p cores
    @param def Default efficiency if p is higher than the maximal width of the task


refid: a0c90cf3bcfe56c8e0602f0c3eaf19c99
name: runtime
definition: double pelib::Task::runtime
type: double
argsstring: (double width=1, double frequency=1) const
scope: pelib::Task
detaileddescription:
Computes and returns the global run time of this task assuming a given width and frequency
    @param width Assume the task run on that many cores
    @param frequency Assumes the task runs at this frequency


refid: aa1a93e76e1f1d9c8b358562de63aecb3
name: Taskgraph
definition: pelib::Taskgraph::Taskgraph
argsstring: (const set< Task > &tasks, const set< Link > &links)
scope: pelib::Taskgraph
detaileddescription:
Constructor
    @param tasks Set of tasks in the application
    @param links Set of links between tasks in the application


refid: aa9184dfd2719288cdfc54c2850d01dbd
name: operator=
definition: Taskgraph & pelib::Taskgraph::operator=
type: Taskgraph &
argsstring: (const Taskgraph &copy)
scope: pelib::Taskgraph
detaileddescription:
Copies all tasks and set links to task copies in the taskgraph instance that receives the assignment  


refid: a765a3cb06ffbd6f4e3e680b9f129c166
name: dump
definition: virtual void pelib::TaskgraphOutput::dump
type: void
argsstring: (std::ostream &os, const Taskgraph &data, const Platform &arch) const =0
scope: pelib::TaskgraphOutput
detaileddescription:
Writes a pelib::Taskgraph instance into output stream
    @param os Output stream to write Taskgraph
    @param data Instance of pelib::Taskgraph to be written
    @param arch Allows TaskgraphOut concrete implementation to write only information useful for this platform


refid: a4bdc1931165e489b2ef8d93eec65dc74
name: Vector
definition: pelib::Vector< Key, Value >::Vector
argsstring: (const std::string name, const VectorType values)
scope: pelib::Vector< Key, Value >
detaileddescription:
Constructor
    @param name name associated to this vector
    @param values Values held in the vector associated to an ordered set of indexes


refid: a1c1653f80ad45edf11ebcfaabff02cba
name: dump
definition: virtual void pelib::XMLSchedule::dump
type: void
argsstring: (std::ostream &os, const Schedule *data, const Taskgraph *tg, const Platform *pt) const
scope: pelib::XMLSchedule
detaileddescription:
Writes the content of instance of pelib::Schedule into output stream in XML format, using additional information from associated taskgraph and platform  


refid: a43ab11519201bb5e610a4a2f3d0236fc
name: integrate
definition: T exprtk::integrate
type: T
scope: exprtk
argsstring:
(expression< T > &e, const std::string &variable_name, const T &r0, const T &r1, const std::size_t number_of_intervals=1000000)


refid: a4e547c02fd3cadcc110fda81e3a70e2c
name: pelib_argument_stream_parse
definition: unsigned int pelib_argument_stream_parse
type: unsigned int
argsstring: (char **argv, pelib_argument_stream_t *stream)
detaileddescription:
Performs parsing operations stores data gather in a pelib_argument stream instance
    @param argv Array of strings containing all data to be parsed. Its last element must be a NULL pointer.
    @param stream Instance of pelib argument_stream that holds the data being parsed


refid: a624247fce720a5e15eea1ab00a342e39
name: array_length_pre_debug
initializer:
printf("[PELIB:%s:%s:%d] length = %d\n", __FILE__, __FUNCTION__, __LINE__, pelib_array_length(ARRAY_T)(&array));


refid: ad128be028e25819ad04a79f836e758af
name: array_t
definition: array_t
argsstring: (ARRAY_T)
detaileddescription:
Reads length value_t elements from filename, and skip the offset first elements.
\param filename: File to open and read values from
\param offset: number of elements of value_t to skip before reading the values
\param length: number of elements to read. If length < 0, then reads the remaining number of elements available in the file
\return: an array of capacity of length, or the number or elements stored in the array file if length below 0. If not enough elements could be skipped, then returns NULL  

Load an instance of array from a binary file. The capacity of the array equals the number of elements loaded  

Load the number of elements in a array from a binary file, but not the data itself. The capacity of the array equals the number of elements loaded  

Load only a portion of the data stored in a binary file. The capacity of the array equals the number of elements loaded
    @param Index of the first element to be loaded. This element is stored at offset 0 in this array instance
    @param to Index of the last element to be loaded


refid: a7e7b8489350771739d94331d58bf6da6
name: ARRAY_T
definition: int pelib_array_checkascending() ARRAY_T
type: int pelib_array_checkascending()
argsstring: (array_t(ARRAY_T)*array)
detaileddescription:
Returns 0 if elements in an array are not sorted in non-decreasing order  

Returns the length of the array, that is the number of elements stored in it  

Returns the maximum number of elements this array can hold  


refid: aee4e3268bd844fdec413f1cdd70b5497
name: ARRAY_T
definition: int pelib_array_append() ARRAY_T
type: int pelib_array_append()
argsstring: (array_t(ARRAY_T)*array, ARRAY_T val)
detaileddescription:
Write elem in array instance at index defined by the array's length
    @return 0 if this array is already full


refid: ad23c8e225c4f24cfc5b75c87b12abd89
name: ARRAY_T
definition: int pelib_array_compare() ARRAY_T
type: int pelib_array_compare()
argsstring: (array_t(ARRAY_T)*a1, array_t(ARRAY_T)*a2)
detaileddescription:
Compares all elements of two arrays one by one
    @return If a1 and a2 have the same number of elements, for the first pair of elements from both arrays a1 and a2 that are different, return -1 if the element of a1 is lower than the element of a2, 1 otherwise. Returns 0 if all elements are identical. If a1 has less elements than a2, then returns -1 other wise returns 1.


refid: a615fb2498e35a2dc4c5b5df74480fc3d
name: array
definition: struct array
type: struct
argsstring: (ARRAY_T)
detaileddescription: Generic static array
inbodydescription:
Maximum elements in the array  

Number of elements currently stored in the array  

Address where elements are stored  


refid: ace688c8130c27f6a65d00b0f6f3a5c5c
name: array_t
definition: array_t
argsstring: (ARRAY_T)*pelib_array_loadfilename(ARRAY_T)(char *)
detaileddescription:
Load an instance of array from a text file. The capacity of the array equals the number of elements loaded  

Load an instance of array from a binary file. The capacity of the array equals the number of elements loaded  

Load the number of elements in a array from a binary file, but not the data itself. The capacity of the array equals the number of elements loaded  

Load only a portion of the data stored in a binary file. The capacity of the array equals the number of elements loaded
    @param Index of the first element to be loaded. This element is stored at offset 0 in this array instance
    @param to Index of the last element to be loaded


refid: a15c17236a42dc139185b839909c2e48a
name: load_lib
definition: void* load_lib
type: void *
argsstring: (const char *library)
detaileddescription:
Dynamically loads a dynamic library through its filename
    @param library Filename of the library to be loaded
    @return Handler for the library loaded


refid: a8379912943229aafc3966de1d1e91ef4
name: load_function
definition: void* load_function
type: void *
argsstring: (void *handle, const char *function)
detaileddescription:
Extracts a function pointer from a dynamically laoded function
    @param Handle Dynmic Library handle obtained with load_lib()
    @param Function Name of the function in the library to be run
    @return Function pointer ready to be called


refid: a2a84a2155f1dae04c77a60b7d458449c
name: exprtk_define_unary_function
initializer:
template <typename T>                                \
         inline T FunctionName (const T v)                    \
         {                                                    \
            typename details::number_type<T>::type num_type;  \
            return  FunctionName##_impl(v,num_type);          \
         }                                                    \


refid: a2705ae88eddc1e5fd7ebdcba84191199
name: exprtk_process_digit
initializer:
if ((digit = (*itr++ - '0')) < 10) result = result * 10 + (digit); else { return_result = false; break; }


refid: a828ca9d6b533fa81981411f0de9b1b00
name: define_sfop3
initializer:
template <typename T>                              \
      struct sf##NN##_op : public sf_base<T>             \
      {                                                  \
         typedef typename sf_base<T>::Type Type;         \
         static inline T process(Type x, Type y, Type z) \
         {                                               \
            return (OP0);                                \
         }                                               \
         static inline std::string id()                  \
         {                                               \
            return OP1;                                  \
         }                                               \
      };                                                 \


refid: a121701b2276b29d8d6352d7c04395ad5
name: define_sfop4
initializer:
template <typename T>                                      \
      struct sf##NN##_op : public sf_base<T>                     \
      {                                                          \
         typedef typename sf_base<T>::Type Type;                 \
         static inline T process(Type x, Type y, Type z, Type w) \
         {                                                       \
            return (OP0);                                        \
         }                                                       \
         static inline std::string id() { return OP1; }          \
      };                                                         \


refid: a75c4afc2b751e98886135de19bb8180d
name: exprtk_define_unary_op
initializer:
template <typename T>                                                                                     \
      struct OpName##_op                                                                                        \
      {                                                                                                         \
         typedef typename functor_t<T>::Type Type;                                                              \
         static inline T process(Type v) { return numeric:: OpName (v); }                                       \
         static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_##OpName; } \
         static inline details::operator_type operation() { return details::e_##OpName; }                       \
      };                                                                                                        \


refid: acbe6789de03ec130096849364498e21a
name: synthesis_node_type_define
initializer:
template <typename T, typename T0, typename T1>                                                           \
      struct nodetype_T0oT1<T,T0_,T1_> { static const typename expression_node<T>::node_type result; };         \
      template <typename T, typename T0, typename T1>                                                           \
      const typename expression_node<T>::node_type nodetype_T0oT1<T,T0_,T1_>::result = expression_node<T>:: v_; \


refid: a688094578e123e481db34833d6940b8b
name: synthesis_node_type_define
initializer:
template <typename T, typename T0, typename T1, typename T2>                                                     \
      struct nodetype_T0oT1oT2<T,T0_,T1_,T2_> { static const typename expression_node<T>::node_type result; };         \
      template <typename T, typename T0, typename T1, typename T2>                                                     \
      const typename expression_node<T>::node_type nodetype_T0oT1oT2<T,T0_,T1_,T2_>::result = expression_node<T>:: v_; \


refid: a8d6828343d0c59e60d0362ee4abd1884
name: synthesis_node_type_define
initializer:
template <typename T, typename T0, typename T1, typename T2, typename T3>                                               \
      struct nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_> { static const typename expression_node<T>::node_type result; };         \
      template <typename T, typename T0, typename T1, typename T2, typename T3>                                               \
      const typename expression_node<T>::node_type nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_>::result = expression_node<T>:: v_; \


refid: a1a8119ecddcd4d511aaf1a67dc362ee4
name: base_opr_case
initializer:
case N : {                                                      \
                                 expression_node_ptr pl##N[N] = {0};                 \
                                 std::copy(param_list,param_list + N,pl##N);         \
                                 return expression_generator_(operation.type,pl##N); \
                              }                                                      \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                 \
                             allocate<typename details::unary_variable_node<Type,op1<Type> > >(v); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                           \
                             allocate<typename details::unary_vector_node<Type,op1<Type> > > \
                                (operation,branch[0]);                                       \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                       \
                             allocate<typename details::unary_branch_node<Type,op1<Type> > >(branch[0]); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : temp_node = node_allocator_->                    \
                             allocate<details::sf3_node<Type,op1<Type> > > \
                                (operation,branch);                        \
                          break;                                           \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                 \
                             allocate_rrr<details::sf3_var_node<Type,op1<Type> > > \
                                (v0,v1,v2);                                        \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                            \
                                allocate<details::sf3_node<Type,op1<Type> > >(operation,branch); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : temp_node = node_allocator_->                                                   \
                                         allocate<details::sf4_node<Type,op1<Type> > >(operation,branch); \
                          break;                                                                          \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                \
                             allocate_rrrr<details::sf4_var_node<Type,op1<Type> > >(v0,v1,v2,v3); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                            \
                             allocate<details::sf4_node<Type,op1<Type> > >(operation,branch); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : temp_node = node_allocator_->                                   \
                                         allocate<details::vararg_node<Type,op1<Type> > > \
                                            (arg_list);                                   \
                          break;                                                          \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                          \
                             allocate<details::vararg_varnode<Type,op1<Type> > >(arg_list); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                             \
                                allocate<details::vectorize_node<Type,op1<Type> > >(arg_list[0]); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                       \
                             allocate<details::vararg_node<Type,op1<Type> > >(arg_list); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                         \
                                template allocate_rrr<typename details::assignment_op_node<Type,op1<Type> > > \
                                   (operation,branch[0],branch[1]);                                           \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                                   \
                                 template allocate_rrr<typename details::assignment_vec_elem_op_node<Type,op1<Type> > > \
                                    (operation,branch[0],branch[1]);                                                    \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                                \
                                   template allocate_rrr<typename details::assignment_vecvec_op_node<Type,op1<Type> > > \
                                      (operation,branch[0],branch[1]);                                                  \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                             \
                                   template allocate_rrr<typename details::assignment_vec_op_node<Type,op1<Type> > > \
                                      (operation,branch[0],branch[1]);                                               \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                         \
                                template allocate_rrr<typename details::eqineq_vecvec_node<Type,op1<Type> > > \
                                   (operation,branch[0],branch[1]);                                           \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                         \
                                template allocate_rrr<typename details::eqineq_vecval_node<Type,op1<Type> > > \
                                   (operation,branch[0],branch[1]);                                           \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                         \
                                template allocate_rrr<typename details::eqineq_valvec_node<Type,op1<Type> > > \
                                   (operation,branch[0],branch[1]);                                           \


refid: a9ce422bb0c87c9728b6c283695afe4f4
name: vector_ops
initializer:
case_stmt(details::e_add,details::add_op) \
            case_stmt(details::e_sub,details::sub_op) \
            case_stmt(details::e_mul,details::mul_op) \
            case_stmt(details::e_div,details::div_op) \
            case_stmt(details::e_mod,details::mod_op) \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                           \
                                template allocate_rrr<typename details::vecarith_vecvec_node<Type,op1<Type> > > \
                                   (operation,branch[0],branch[1]);                                             \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                           \
                                template allocate_rrr<typename details::vecarith_vecval_node<Type,op1<Type> > > \
                                   (operation,branch[0],branch[1]);                                             \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                           \
                                template allocate_rrr<typename details::vecarith_valvec_node<Type,op1<Type> > > \
                                   (operation,branch[0],branch[1]);                                             \


refid: a0a462291371d9f7abf9bdfa62564e3aa
name: basic_opr_switch_statements
initializer:
case_stmt(details::e_add,details::add_op) \
         case_stmt(details::e_sub,details::sub_op) \
         case_stmt(details::e_mul,details::mul_op) \
         case_stmt(details::e_div,details::div_op) \
         case_stmt(details::e_mod,details::mod_op) \
         case_stmt(details::e_pow,details::pow_op) \


refid: ac8620d988e51727c0b6ef888842fc5fe
name: extended_opr_switch_statements
initializer:
case_stmt(details::  e_lt,details::  lt_op) \
         case_stmt(details:: e_lte,details:: lte_op) \
         case_stmt(details::  e_gt,details::  gt_op) \
         case_stmt(details:: e_gte,details:: gte_op) \
         case_stmt(details::  e_eq,details::  eq_op) \
         case_stmt(details::  e_ne,details::  ne_op) \
         case_stmt(details:: e_and,details:: and_op) \
         case_stmt(details::e_nand,details::nand_op) \
         case_stmt(details::  e_or,details::  or_op) \
         case_stmt(details:: e_nor,details:: nor_op) \
         case_stmt(details:: e_xor,details:: xor_op) \
         case_stmt(details::e_xnor,details::xnor_op) \


refid: affb24b4a4452562c756a136514686982
name: case_stmt
initializer:
case cp : return node_allocator_->                                        \
                            allocate<IPowNode<T,details::numeric::fast_exp<T,cp> > >(v); \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                         \
                                template allocate<typename details::binary_ext_node<Type,op1<Type> > > \
                                   (branch[0],branch[1]);                                              \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rc<typename details::vob_node<Type,op1<Type> > > \
                                   (v,branch[1]);                                                  \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::bov_node<Type,op1<Type> > > \
                                   (branch[0],v);                                                  \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_tt<typename details::cob_node<Type,op1<Type> > > \
                                   (c,branch[1]);                                                  \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::boc_node<Type,op1<Type> > > \
                                   (branch[0],c);                                                  \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rr<typename details::vov_node<Type,op1<Type> > > \
                                   (v1,v2);                                                        \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::cov_node<Type,op1<Type> > > \
                                   (c,v);                                                          \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rc<typename details::voc_node<Type,op1<Type> > > \
                                   (v,c);                                                          \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return details::T0oT1oT2_sf3ext<T,T0,T1,T2,op1<Type> >:: \
                                allocate(*(expr_gen.node_allocator_),t0,t1,t2);       \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,op1<Type> >:: \
                                allocate(*(expr_gen.node_allocator_),t0,t1,t2,t3);             \


refid: ad37bbe0cd88ca24213e794474cd85e91
name: string_opr_switch_statements
initializer:
case_stmt(details::  e_lt ,details::   lt_op) \
         case_stmt(details:: e_lte ,details::  lte_op) \
         case_stmt(details::  e_gt ,details::   gt_op) \
         case_stmt(details:: e_gte ,details::  gte_op) \
         case_stmt(details::  e_eq ,details::   eq_op) \
         case_stmt(details::  e_ne ,details::   ne_op) \
         case_stmt(details::e_in   ,details::   in_op) \
         case_stmt(details::e_like ,details:: like_op) \
         case_stmt(details::e_ilike,details::ilike_op) \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                                 \
                             allocate_ttt<typename details::str_xrox_node<Type,T0,T1,range_pack,op1<Type> >,T0,T1> \
                                (s0,s1,rp0);                                                                       \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                                 \
                             allocate_ttt<typename details::str_xoxr_node<Type,T0,T1,range_pack,op1<Type> >,T0,T1> \
                                (s0,s1,rp1);                                                                       \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                                   \
                             allocate_tttt<typename details::str_xroxr_node<Type,T0,T1,range_pack,op1<Type> >,T0,T1> \
                                (s0,s1,rp0,rp1);                                                                     \


refid: a6b719a55eac08db92c48ebfd64796cfb
name: case_stmt
initializer:
case op0 : return node_allocator_->                                                        \
                             allocate_tt<typename details::sos_node<Type,T0,T1,op1<Type> >,T0,T1>(s0,s1); \


refid: af7e957d5182a1b0fb8dd11f014c872e3
name: register_sf3
initializer:
sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \


refid: a075ddb6ee19140ad124569fce0261ed7
name: register_sf4
initializer:
sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \


refid: a884095bb8479d1125dc7f014180398fb
name: register_sf4ext
initializer:
sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \


refid: ae14b2cd6fa3534cdbe2043d84334ccc1
name: CFIFO_T
definition: static int is_in_content() CFIFO_T
type: int is_in_content()
argsstring: (cfifo_t(CFIFO_T)*fifo, size_t index)
detaileddescription:
Returns an integer whose bits represent (if set):
0: always set to 1
1: index in position of read index
2: index in position of write index
value is made negative if index is not in data area


refid: adf74d11d469daeeafe83efd6cb68f32d
name: CFIFO_T
definition: CFIFO_T* pelib_cfifo_peekaddr() CFIFO_T
type: CFIFO_T *pelib_cfifo_peekaddr()
argsstring: (cfifo_t(CFIFO_T)*fifo, size_t offset, size_t *num, CFIFO_T **addr)
detaileddescription:
Returns an address that contains elements to be read. If num is not NULL and if there is at least one element available, writes the number of elements available in address pointer by num. If no element is available, returns NULL and writes nothing in other parameters. Note that *num may take a lower value than pelib_cfifo_length() if pelib_cfifo_length() >= 2. In this case, if remaining is not null, then remaining is set to point to the the rest of the data; otherwise it is set to NULL.  


refid: ad555fb96d4df1eb70ccf8de3c5395c4e
name: CFIFO_T
definition: CFIFO_T* pelib_cfifo_writeaddr() CFIFO_T
type: CFIFO_T *pelib_cfifo_writeaddr()
argsstring: (cfifo_t(CFIFO_T)*fifo, size_t *num, CFIFO_T **addr)
detaileddescription:
Returns an address that can hold new elements. If num is not NULL and if there is at least one memory element available, writes the number of additional elements the fifo can store in address pointer by num. If no memory is available, returns NULL and writes nothing in other parameters. Note that *num may take a lower value than pelib_cifo_capacity() - pelib_cfifo_length(). In this case and if remaining is non-null, remaining points to the extra memory buffer. Otherwise, it is set to NULL.  


refid: aca2a0153ddf4ea813df84ad36472970a
name: CFIFO_T
definition: size_t pelib_cfifo_pushmem() CFIFO_T
type: size_t pelib_cfifo_pushmem()
argsstring: (cfifo_t(CFIFO_T)*fifo, CFIFO_T *mem, size_t num)
detaileddescription:
Pushes all n elements stored in some memory address and update
    @param Address of the first element to be pushed
    @param n Number of elements to push
    @return Number of elements that could be pushed. Lower than n if there is not enough space to write all elements

Pops n elements and copy them into memory pointed by addr and update the fifo head element
    @param addr Address where the first element popped is written
    @param n Number of elements to pop
    @return Number of elements actually popped. May be lower than n if there are not enough elemennts stored


refid: ae54f0deec750a66bb0d3f739f36fc985
name: CFIFO_T
definition: size_t pelib_cfifo_peekmem() CFIFO_T
type: size_t pelib_cfifo_peekmem()
argsstring: (cfifo_t(CFIFO_T)*fifo, CFIFO_T *mem, size_t num, size_t offset)
detaileddescription:
Copies the n first elements into addr but do not discard any element in the fifo
    @param n Number of elements to peek from fifo
    @param offset Number of elements to skip before reading
    @return Number of elemetns that could actually be read


refid: aff091a41127133639e0c6148c252db13
name: CFIFO_T
definition: size_t pelib_cfifo_popfifo() CFIFO_T
type: size_t pelib_cfifo_popfifo()
argsstring: (cfifo_t(CFIFO_T)*src, cfifo_t(CFIFO_T)*tgt, size_t num)
detaileddescription:
Pops n elements from fifo and pushes them into fifo dest
    @param dest Fifo that receives the elements popped
    @param n number of elements to pop
    @return Number of elements actually pushed in fifo dest


refid: a9f76d82cdea38fb1a10ba2851bda8edd
name: cfifo
definition: struct cfifo
type: struct
argsstring: (CFIFO_T)
detaileddescription: generic circular fifo
inbodydescription:
index of the next element to read at the next pop operation  

index of the next element able to receive new data at the next push operation  

Last operation, push or pop, performed on this circular fifo. Set to PELIB_CFIFO_POP at fifo initialization  

Maximum number of elements this fifo can hold at a given time  

Pointer to the memory portion that hold the data  


refid: ac25ccd7d439767edeb85c024cdc41e98
name: CFIFO_T
definition: size_t pelib_cfifo_fill() CFIFO_T
type: size_t pelib_cfifo_fill()
argsstring: (cfifo_t(CFIFO_T)*, size_t n)
detaileddescription:
Assumes n elements have been written to the fifo and set the write structire member accordingly  

Discards n elements from the head of the fifo  

Reads the head element but doesn't set the hed to the next element
    @param offset Skip the first offset elements before reading


refid: a71b2996792de0d1a14d0b00ba27ea5b6
name: CFIFO_T
definition: CFIFO_T pelib_cfifo_pop() CFIFO_T
type: CFIFO_T pelib_cfifo_pop()
argsstring: (cfifo_t(CFIFO_T)*)
detaileddescription:
Returns the head of the fifo and set the head to the next element  

Returns 0 if at least one push operation can be performed on the fifo  

Returns 0 if there is at least one element stored in the fifo  

Returns the number of elements available in the fifo  

Returns the number that was last written in the fifo  

Returns the maximum number of elements this fifo can contain  


refid: a25e668a352b3e5c0fa21f68879e0f632
name: cfifo_t
definition: cfifo_t
argsstring: (CFIFO_ARRAY_T)
detaileddescription:
Allocates and initialize an instance of pelib fifo from the data of a pelib array. The new fifo contains all data and free space in the pelib array  


refid: acf433a4ffd7fc00eadcfd7f86eded3ee
name: array_t
definition: array_t
argsstring: (CFIFO_ARRAY_T)
detaileddescription:
Allocates and initialize an instance of pelib array from the data of a pelib fifo. The new array's capacity is the number of elements already in the fifo. The new array has no free element left (the append operation cannot succeed)  


refid: ae5a73a6b501fc0b0d98a241557d8392d
name: pelib_dump
definition: void pelib_dump
type: void
argsstring: (std::ostream &cout, std::map< const char *, pelib::Record * > records, size_t argc, char **argv)
detaileddescription:
Writes objects contained in records to output stream. Options can be passed using the string array argv and the number of arguments in argc. Note that call elements of argv and argv itself are freed after this function terminates.


refid: aa986fdd06d5ed45e184bf99c1f18fa98
name: pelib_parse
definition: pelib::Record* pelib_parse
type: pelib::Record *
argsstring: (std::istream &cin, size_t argc, char **argv)
detaileddescription:
Parses the content of an input stream with string options and produces a class instance derived from pelib::Record. Used for dynamic library parsers  


refid: a259991e0f8cea2dc7fb68333505cf14f
name: pelib_sample
definition: int pelib_sample
type: int
argsstring: (array_t(int)*a, int size, int start, int stop)
detaileddescription:
Computes a pivot from a sample of an array
    @param a Array to compute a pivot from
    @param size Number of elements fo pick to compute a pivot
    @param start Minimal index from which to pick samples
    @param stop Maximal index from which to pick samples


refid: a2ecf8aed5336c717924a6cb45067ac78
name: pelib_insertsort_window
definition: void pelib_insertsort_window
type: void
argsstring: (array_t(int)*a, int begin, int end)
detaileddescription:
Insert sort in a subset of an array
    @param a Array to sort
    @param begin Index of the first element of the subarray to run insert sort on
    @param end Index of the last element of the subarray to run insert sort on


refid: aa5fcf317e140992a9dbeac691ebe738c
name: STACK_T
definition: int pelib_stack_check() STACK_T
type: int pelib_stack_check()
argsstring: (stack_t(STACK_T)*s)
detaileddescription:
Returns 0 if the stack is not in a consistent state  

Returns 0 is the stack holds at least one element  


refid: aaf8969a949d0417c7c44e4de9e3579a6
name: STACK_T
definition: int pelib_stack_push() STACK_T
type: int pelib_stack_push()
argsstring: (stack_t(STACK_T)*s, STACK_T buffer)
detaileddescription:
Allocates a new stack element, write the element in it and push it to the stack  

Pushes an element to the stack in a thread-safe manner  


refid: a9c80cf813dd4b2ebd4d07d2db736032d
name: STACK_T
definition: int pelib_stack_pop() STACK_T
type: int pelib_stack_pop()
argsstring: (stack_t(STACK_T)*s, STACK_T *buffer)
detaileddescription:
Read value from the head stack element, removes the head stack element and free the stack element  

Read the head value from the stack but doesn't remove the head element  

Pops an element to the stack in a thread-safe manner  


refid: a60978ea900156f0579720968ef2079c9
name: STACK_T
definition: int pelib_stack_pop_elem() STACK_T
type: int pelib_stack_pop_elem()
argsstring: (stack_t(STACK_T)*s, stackelem_t(STACK_T)**elem)
detaileddescription:
Pops the head element of the stack without reading its value or freeing it  

Pops a stack element in thread-safe manner  


refid: a4c013c31d33eda373419b8f51df0ccd3
name: STACK_T
definition: int pelib_stack_push_safe_managed() STACK_T
type: int pelib_stack_push_safe_managed()
argsstring: (stack_t(STACK_T)*s, stack_t(STACK_T)*pool, STACK_T buffer)
detaileddescription:
Pushes a new value in the stack, reusing a stack element from a stack element recycling bin. Allocates a new element if the recycle bin is empty
    @param stack Stack that receives the new element
    @param bin Recycle bin (stack) that contains stack element to be reused
    @param value Value to be pushed in the stack
    @return 0 If the push operation could not be performed


refid: a4f0bb6c2621d1e6cfefe215122ab716c
name: STACK_T
definition: int pelib_stack_pop_safe_managed() STACK_T
type: int pelib_stack_pop_safe_managed()
argsstring: (stack_t(STACK_T)*s, stack_t(STACK_T)*pool, STACK_T *buffer)
detaileddescription:
Pops the head value of a stack, saves the stack element popped in a recycling bin and writes the value read in ptr
    @param stack Stack toread head element from
    @param bin Stack element recycle bin
    @param ptr Memory address where the value popped is written


refid: a3e599628411fe1761b04e3977e7a451a
name: stackelem
definition: struct stackelem
type: struct
argsstring: (STACK_T)
detaileddescription:
Generic element of a stack that holds data pushed and pointer to the next element  

Space-less type alias for struct stackelem  


refid: acbcac18aa413fb0ed352651868141a8b
name: STRUCT_T
definition: STRUCT_T* pelib_alloc_struct() STRUCT_T
type: STRUCT_T *pelib_alloc_struct()
argsstring: ()
detaileddescription:
Allocates the base structure of a pelib object
    @return A pointer to the newly allocated base structure

Allocate a new pelib simple data structure
    @return A pointer to a newly allocated data structure


refid: ae447e8bb7a663b0b95a0212db9c16c79
name: STRUCT_T
definition: int pelib_alloc_buffer() STRUCT_T
type: int pelib_alloc_buffer()
argsstring: (STRUCT_T *obj, size_t n)
detaileddescription:
Allocates the buffer of a pelib collection
    @param obj Pointer to pelib colelction that will receive the buffer
    @param n Number of element this buffer should accept


refid: a560a46d20ab2538b055dc4300a4ebfea
name: STRUCT_T
definition: int pelib_set_buffer() STRUCT_T
type: int pelib_set_buffer()
argsstring: (STRUCT_T *obj, void *buffer, size_t n)
detaileddescription:
Replaces the buffer of a pelib collection with a new memory address. The reference to the old buffer is lost and the old buffer is not freed
    @param obj Pelib collection whose buffer is replaced
    @param buffer New buffer for the pelib collection
    @param n Number of element the new buffer can hold
    @return 0 if the operation failed and non-zero otherwise


refid: adf5f52004ed734eca87adc716a465bf7
name: STRUCT_T
definition: STRUCT_T* pelib_alloc_collection() STRUCT_T
type: STRUCT_T *pelib_alloc_collection()
argsstring: (size_t n)
detaileddescription:
Allocates a new pelib collection without initializing it
    @param n Number of element the collection can hold after instanciation
    @return Pointer to newly instanciated pelib collection


refid: a0f178f32d4229275b3ba80f171af3255
name: STRUCT_T
definition: STRUCT_T* pelib_alloc_from() STRUCT_T
type: STRUCT_T *pelib_alloc_from()
argsstring: (void *buffer, size_t n)
detaileddescription:
Allocate a new pelib collection and uses an existing memory location as buffer
    @param buffer Address of the memory to use as buffer
    @param n Number of elements the new collection can hold
    @return Newly allocated pelib collection


refid: afde1b194aca127f0a2dbd0d71b6f3aad
name: STRUCT_T
definition: int pelib_init() STRUCT_T
type: int pelib_init()
argsstring: (STRUCT_T *obj)
detaileddescription:
Initializes a newly allocated pelib object
    @param obj Pelib object instance to be initialized
    @return 0 if the operation failed and non-zero otherwise

Frees the memory associated to the base structure of a pelib object
    @param obj Pelib object to be freed
    @return 0 if the operation failed and non-zero otherwise

Frees the memory associated to the buffer of a pelib collection
    @param Pelib collection whose buffer is to be freed
    @return 0 if the operation failed and non-zero otherwise

Frees a comple pelib simple or collection object, including its buffer
    @return 0 if the operation failed and non-zero otherwise


refid: a9b09cd10a94224d8842206a3c2b000ba
name: STRUCT_T
definition: int pelib_copy() STRUCT_T
type: int pelib_copy()
argsstring: (STRUCT_T src, STRUCT_T *dst)
detaileddescription:
Copies a pelib object instance to another
    @param src Pelib object source
    @param dst Pelib object that receives the copy


refid: a6f608f61b357058bc054235fc4a5cc0f
name: STRUCT_T
definition: int pelib_destroy() STRUCT_T
type: int pelib_destroy()
argsstring: (STRUCT_T)
detaileddescription:
Destroys a pelib object before its memory is freed
    @return 0 if the operation failed and non-zero otherwise

Returns a simple human-readable string representation of an instance of pelib object  


refid: a4a2d766bcd5b2cd3dcd7551a3879652e
name: STRUCT_T
definition: FILE* pelib_printf() STRUCT_T
type: FILE *pelib_printf()
argsstring: (FILE *str, STRUCT_T obj)
detaileddescription:
Writes a simple human-readable representation of a pelib object instance to some stream
    @param str Output stream to write the object to
    @param obj Pelib object to be written
    @return output stream after the pelib object was written


refid: ae385fbc178d6b1ba2f9e5c7cdf02e652
name: STRUCT_T
definition: FILE* pelib_printf_detail() STRUCT_T
type: FILE *pelib_printf_detail()
argsstring: (FILE *str, STRUCT_T obj, int lvl)
detaileddescription:
Writes a detailed human-redable representation of a pelib object instance to some stream
    @param str Output stream to write the object to
    @param obj Pelib object to be written
    @param lvl Level of details to be written to output stream. For a collection, will write all elements in the collection with detail level = lvl - 1. Useful to display collections of complex objects and visualize all objects in details in a single line of code
    @return Output stream after the object instance was written


refid: ac7405c415b622e5e0628d30e8677c07d
name: STRUCT_T
definition: size_t pelib_fwrite() STRUCT_T
type: size_t pelib_fwrite()
argsstring: (STRUCT_T obj, FILE *str)
detaileddescription:
Writes a pelib object instance to output stream. pelib_fread must be able to read back the written object instance and store it to memory
    @param obj Pelib object instance to be written
    @param str output stream that receives the written pelib object instance
    @return Number of bytes written


refid: a502913b7b1b0163579c35c9ee7e97967
name: STRUCT_T
definition: size_t pelib_fread() STRUCT_T
type: size_t pelib_fread()
argsstring: (STRUCT_T *obj, FILE *str)
detaileddescription:
Reads a pelib object from input stream produced by pelib_fwrite and write it in an existing pelib object instance
    @param obj Pointer to object that receives the data read from input stream
    @param str Input stream whose content is produced by pelib_fwrite to read data from
    @return Number of bytes read


refid: abbf4e61ccdfac05264728b7a7cc43e81
name: STRUCT_T
definition: char* pelib_string_detail() STRUCT_T
type: char *pelib_string_detail()
argsstring: (STRUCT_T, int)
detaileddescription:
Returns a detailed view human-readable string representation of an instance of pelib object. For a collection, the same function is run for all pelib object instances held is the collection with a lower level value.
    @param obj Pelib object to be written to
    @param lvl Level of details to be generated


refid: a96629dbc0f09b5ed93b3d51937d8f359
name: debug
initializer:
cerr << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << #expr << " = \"" << expr << "\"." << endl;


refid: a96629dbc0f09b5ed93b3d51937d8f359
name: debug
initializer:
cout << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << #expr << " = \"" << expr << "\"." << endl;


refid: a312cbb577be66e504db6788ddfc12faf
name: test_run
initializer:
printf("[%s:%s:%i] Running test '%s'... ", __FILE__, __FUNCTION__, __LINE__, #test);\
  test_setup();\
  if(test())\
  {\
    printf("passed\n");\
  }\
  else\
  {\
    printf("failed\n");\
  }\
  test_teardown();


refid: a96629dbc0f09b5ed93b3d51937d8f359
name: debug
initializer:
cout << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << (#expr) << " = \"" << (expr) << "\"." << endl;


