ced27a69c6
PropertyExpressionEngine is changed to derived from a new class PropertyExpressionContainer, which is in turn derives from PropertyXLinkContainer. This makes PropertyExpressionEngine a link type property that is capable of external linking. It now uses the unified link property APIs for dependency management and tracking of object life time, re-labeling, etc. ObjectIdentifier is modified to support sub-object reference, but is not exposed to end-user, because expression syntax is kept mostly unchanged, which will be submitted in future PR. There is, however, one small change in expression syntax (ExpressionParser.y) to introduce local property reference to avoid ambiguity mentioned in FreeCAD/FreeCAD#1619 Modified Expression/ExpressionModifier interface to support various link property API for link modification.
154 lines
5.2 KiB
C++
154 lines
5.2 KiB
C++
/***************************************************************************
|
|
* Copyright (c) Eivind Kvedalen (eivind@kvedalen.name) 2015 *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#ifndef RANGE_H
|
|
#define RANGE_H
|
|
|
|
#include <string>
|
|
|
|
namespace App {
|
|
|
|
struct CellAddress;
|
|
|
|
AppExport CellAddress stringToAddress(const char *strAddress, bool silent=false);
|
|
AppExport int decodeColumn(const std::string &colstr, bool silent=false);
|
|
AppExport int decodeRow(const std::string &rowstr, bool silent=false);
|
|
AppExport int validColumn(const std::string &colstr);
|
|
AppExport int validRow(const std::string &rowstr);
|
|
|
|
struct AppExport CellAddress {
|
|
|
|
CellAddress(int row = -1, int col = -1, bool absRow=false, bool absCol=false)
|
|
: _row(row), _col(col), _absRow(absRow), _absCol(absCol)
|
|
{ }
|
|
|
|
CellAddress(const char * address) {
|
|
*this = stringToAddress(address);
|
|
}
|
|
|
|
CellAddress(const std::string & address) {
|
|
*this = stringToAddress(address.c_str());
|
|
}
|
|
|
|
bool parseAbsoluteAddress(const char *txt);
|
|
|
|
inline int row() const { return _row; }
|
|
|
|
inline int col() const { return _col; }
|
|
|
|
void setRow(int r) { _row = r; }
|
|
|
|
void setCol(int c) { _col = c; }
|
|
|
|
inline bool operator<(const CellAddress & other) const { return asInt() < other.asInt(); }
|
|
|
|
inline bool operator==(const CellAddress & other) const { return asInt() == other.asInt(); }
|
|
|
|
inline bool operator!=(const CellAddress & other) const { return asInt() != other.asInt(); }
|
|
|
|
inline bool isValid() { return (row() >=0 && row() < MAX_ROWS && col() >= 0 && col() < MAX_COLUMNS); }
|
|
|
|
inline bool isAbsoluteRow() const { return _absRow; }
|
|
|
|
inline bool isAbsoluteCol() const { return _absCol; }
|
|
|
|
std::string toString(bool noAbsolute=false) const;
|
|
|
|
// Static members
|
|
|
|
static const int MAX_ROWS;
|
|
|
|
static const int MAX_COLUMNS;
|
|
|
|
protected:
|
|
|
|
inline unsigned int asInt() const { return ((_row << 16) | _col); }
|
|
|
|
short _row;
|
|
short _col;
|
|
bool _absRow;
|
|
bool _absCol;
|
|
};
|
|
|
|
/**
|
|
* @brief The Range class is a spreadsheet range iterator. It takes
|
|
* a starting (row, col) and an ending (row, col). Notice that ranges
|
|
* are always at least one element. The next() functions is therefore
|
|
* used e.g as follows:
|
|
*
|
|
* do {
|
|
* ...
|
|
* while (range.next());
|
|
*
|
|
*/
|
|
|
|
class AppExport Range {
|
|
public:
|
|
Range(const char *range);
|
|
|
|
Range(int _row_begin, int _col_begin, int _row_end, int _col_end);
|
|
|
|
Range(const CellAddress & from, const CellAddress & to);
|
|
|
|
bool next();
|
|
|
|
/** Current row */
|
|
inline int row() const { return row_curr; }
|
|
|
|
/** Current column */
|
|
inline int column() const { return col_curr; }
|
|
|
|
/** Position of start of range */
|
|
inline CellAddress from() const { return CellAddress(row_begin, col_begin); }
|
|
|
|
/** Position of end of range */
|
|
inline CellAddress to() const { return CellAddress(row_end, col_end); }
|
|
|
|
/** Start of range as a string */
|
|
inline std::string fromCellString() const { return CellAddress(row_begin, col_begin).toString(); }
|
|
|
|
/** End of range as a string */
|
|
inline std::string toCellString() const { return CellAddress(row_end, col_end).toString(); }
|
|
|
|
/** Current cell as a string */
|
|
inline std::string address() const { return CellAddress(row_curr, col_curr).toString(); }
|
|
|
|
/** The raneg as a string */
|
|
inline std::string rangeString() const {
|
|
return CellAddress(row_begin, col_begin).toString() + ":" + CellAddress(row_end, col_end).toString();
|
|
}
|
|
|
|
CellAddress operator*() const { return CellAddress(row_curr, col_curr); }
|
|
|
|
/** Number of elements in range */
|
|
inline int size() const { return (row_end - row_begin + 1) * (col_end - col_begin + 1); }
|
|
|
|
private:
|
|
int row_curr, col_curr;
|
|
int row_begin, col_begin;
|
|
int row_end, col_end;
|
|
};
|
|
|
|
}
|
|
|
|
#endif // RANGE_H
|