268 lines
9.0 KiB
C++
268 lines
9.0 KiB
C++
/*
|
|
* Copyright (C) 2015-2017 Intel Corporation
|
|
* Copyright (c) 2017, Fuzhou Rockchip Electronics Co., Ltd
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef GCSS_ITEM_H_
|
|
#define GCSS_ITEM_H_
|
|
|
|
#include "gcss.h"
|
|
|
|
namespace GCSS {
|
|
/**
|
|
* Holds type of the item. It can be Node or Attribute (int or string)
|
|
*/
|
|
enum Type {
|
|
NA = (1 << 0),
|
|
STR_ATTRIBUTE = (1 << 1),
|
|
INT_ATTRIBUTE = (1 << 2),
|
|
NODE = (1 << 3)
|
|
};
|
|
/**
|
|
* \class GraphConfigItem
|
|
* Base class that holds attributes or nodes inside
|
|
*/
|
|
class GraphConfigItem
|
|
{
|
|
public:
|
|
typedef std::multimap<ia_uid, GraphConfigItem*> gcss_item_map;
|
|
typedef gcss_item_map::const_iterator const_iterator;
|
|
|
|
/** Getter for int value of attribute. Return error if getValue is being
|
|
* used directly or if child class doesn't implement getValue
|
|
* \param[out] value
|
|
*/
|
|
|
|
virtual css_err_t getValue(int&) {return css_err_noentry;}
|
|
/** Getter for string value of attribute. Return error if getValue is being
|
|
* used directly or if child class doesn't implement getValue
|
|
* \param[out] value
|
|
*/
|
|
|
|
virtual css_err_t getValue(std::string&) {return css_err_noentry;}
|
|
/** Setter for string value of attribute.
|
|
* \param[in] new value
|
|
*/
|
|
|
|
virtual css_err_t setValue(const std::string&) {return css_err_noentry;}
|
|
/** Setter for int value of attribute.
|
|
* \param[in] new value
|
|
*/
|
|
virtual css_err_t setValue(int) {return css_err_noentry;}
|
|
|
|
Type type;
|
|
GraphConfigItem(Type type) : type(type) {}
|
|
|
|
virtual ~GraphConfigItem() {}
|
|
};
|
|
|
|
|
|
inline bool operator<(const ItemUID &r, const ItemUID &l)
|
|
{
|
|
return r.mUids < l.mUids;
|
|
}
|
|
|
|
inline bool operator>(const ItemUID &r, const ItemUID &l)
|
|
{
|
|
return r.mUids > l.mUids;
|
|
}
|
|
|
|
/**
|
|
* \class GraphConfigAttribute
|
|
* Base class for graph config attributes
|
|
*/
|
|
class GraphConfigAttribute : public GraphConfigItem {
|
|
public:
|
|
GraphConfigAttribute() : GraphConfigItem(NA){}
|
|
GraphConfigAttribute(Type t) : GraphConfigItem(t){}
|
|
~GraphConfigAttribute() {}
|
|
};
|
|
|
|
/**
|
|
* \class GraphConfigIntAttribute
|
|
* Container for integer type attributes
|
|
*/
|
|
class GraphConfigIntAttribute : public GraphConfigAttribute
|
|
{
|
|
public:
|
|
GraphConfigIntAttribute() : GraphConfigAttribute(INT_ATTRIBUTE), mInteger(-1){}
|
|
GraphConfigIntAttribute* copy();
|
|
css_err_t getValue(int& intVal){intVal = mInteger; return css_err_none;}
|
|
css_err_t setValue(int intVal) { return insertInteger(intVal);}
|
|
~GraphConfigIntAttribute() {};
|
|
private:
|
|
css_err_t insertInteger(int);
|
|
int mInteger;
|
|
};
|
|
|
|
/**
|
|
* \class GraphConfigStrAttribute
|
|
* Container for string type attributes
|
|
*/
|
|
class GraphConfigStrAttribute : public GraphConfigAttribute
|
|
{
|
|
public:
|
|
GraphConfigStrAttribute() : GraphConfigAttribute(STR_ATTRIBUTE){}
|
|
GraphConfigStrAttribute* copy();
|
|
css_err_t getValue(std::string& str){str = mString; return css_err_none;}
|
|
css_err_t setValue(const std::string& str) { return insertString(str);}
|
|
~GraphConfigStrAttribute() {};
|
|
private:
|
|
css_err_t insertString(const std::string&);
|
|
std::string mString;
|
|
};
|
|
|
|
/**
|
|
* \class GraphConfigNode
|
|
* Provides methods for manipulating nodes in the graph
|
|
*/
|
|
class GraphConfigNode : public GraphConfigItem, public IGraphConfig
|
|
{
|
|
public:
|
|
typedef std::vector<GraphConfigNode*> gcss_node_vector;
|
|
|
|
GraphConfigNode(const GraphConfigNode&);
|
|
GraphConfigNode() : GraphConfigItem(NODE), mAncestor(nullptr){};
|
|
~GraphConfigNode();
|
|
|
|
GraphConfigNode* copy();
|
|
gcss_item_map item;
|
|
void dumpNode();
|
|
static void dumpNodeTree(GraphConfigNode*, int depth = 0);
|
|
const_iterator begin() const { return item.begin(); }
|
|
const_iterator end() const { return item.end(); }
|
|
|
|
css_err_t getAllDescendants(gcss_node_vector&, ia_uid iuid = 0) const;
|
|
css_err_t getAncestor(GraphConfigNode**);
|
|
css_err_t getAttribute(const ia_uid iuid, GraphConfigAttribute** ret) const;
|
|
css_err_t getIntAttribute(const ia_uid, GraphConfigIntAttribute&);
|
|
css_err_t getStrAttribute(const ia_uid, GraphConfigStrAttribute&);
|
|
css_err_t getDescendant(const ia_uid, GraphConfigNode**) const;
|
|
css_err_t getDescendant(const ia_uid attribute,
|
|
const int searchAttributeValue,
|
|
const_iterator& it,
|
|
GraphConfigNode** retNode) const;
|
|
css_err_t getDescendant(const ia_uid attribute,
|
|
const std::string& searchAttributeValue,
|
|
const_iterator& it,
|
|
GraphConfigNode** retNode) const;
|
|
css_err_t getDescendantByString(const std::string &str,
|
|
GraphConfigNode **retNode);
|
|
css_err_t insertDescendant(GraphConfigItem*, const ia_uid);
|
|
|
|
GraphConfigNode* getRootNode(void) const;
|
|
/**
|
|
* Helper function which iterates through given node and search for
|
|
* matching attribute. Return error if not found.
|
|
* \param attribute the ItemUID of attribute to search
|
|
* \param searchAttributeValue the value to search
|
|
* \param it iterator for the node to search
|
|
* \return css_err_t
|
|
*/
|
|
template <typename T>
|
|
css_err_t iterateAttributes(ia_uid attribute,
|
|
const T& searchAttributeValue,
|
|
const const_iterator& it) const
|
|
{
|
|
GraphConfigNode * node = static_cast<GraphConfigNode*>(it->second);
|
|
const_iterator attrIterator = node->begin();
|
|
|
|
while (attrIterator != node->end()) {
|
|
if (attrIterator->first == attribute) {
|
|
GraphConfigAttribute * retAttr =
|
|
static_cast<GraphConfigAttribute*>(attrIterator->second);
|
|
T foundAttrValue;
|
|
css_err_t ret = retAttr->getValue(foundAttrValue);
|
|
|
|
if (ret != css_err_none)
|
|
return ret;
|
|
if (foundAttrValue == searchAttributeValue)
|
|
return css_err_none;
|
|
}
|
|
attrIterator = node->getNext(attrIterator); // Get a next attribute
|
|
}
|
|
return css_err_end;
|
|
}
|
|
|
|
operator IGraphConfig*() { return this; }
|
|
|
|
private:
|
|
GraphConfigItem::const_iterator getNext(const_iterator& it){
|
|
return std::next(it, 1);}
|
|
GraphConfigItem::const_iterator getNextAttribute(
|
|
GraphConfigItem::const_iterator& it) const;
|
|
GraphConfigNode* mAncestor;
|
|
|
|
template <typename T>
|
|
css_err_t getAttrValue(const ia_uid& uid, T& val) const {
|
|
|
|
GraphConfigAttribute * retAttribute;
|
|
css_err_t ret = getAttribute(uid, &retAttribute);
|
|
|
|
if (css_err_none != ret)
|
|
return ret;
|
|
|
|
return retAttribute->getValue(val);
|
|
}
|
|
|
|
template <typename T>
|
|
css_err_t setAttrValue(const ia_uid& uid, T& val) {
|
|
|
|
GraphConfigAttribute * retAttribute;
|
|
css_err_t ret = getAttribute(uid, &retAttribute);
|
|
|
|
if (css_err_none != ret)
|
|
return ret;
|
|
|
|
return retAttribute->setValue(val);
|
|
}
|
|
|
|
public: /* implements IGraphConfig */
|
|
virtual IGraphConfig* getRoot(void) const;
|
|
virtual IGraphConfig* getAncestor(void) const;
|
|
virtual IGraphConfig* getDescendant(ia_uid uid) const;
|
|
virtual IGraphConfig* getDescendant(const ItemUID&) const;
|
|
virtual IGraphConfig* getDescendantByString(const std::string &str) const;
|
|
virtual IGraphConfig* iterateDescendantByIndex(const ia_uid attribute,
|
|
uint32_t &index) const;
|
|
virtual IGraphConfig* iterateDescendantByIndex(const ia_uid attribute,
|
|
const ia_uid value,
|
|
uint32_t &index) const;
|
|
virtual uint32_t getDescendantCount() const;
|
|
virtual css_err_t getValue(ia_uid, int&) const;
|
|
virtual css_err_t getValue(const ItemUID&, int&) const;
|
|
|
|
virtual css_err_t getValue(ia_uid, std::string&) const;
|
|
virtual css_err_t getValue(const ItemUID&, std::string&) const;
|
|
|
|
virtual css_err_t setValue(ia_uid, int);
|
|
virtual css_err_t setValue(const ItemUID&, int);
|
|
|
|
virtual css_err_t setValue(ia_uid, const std::string&);
|
|
virtual css_err_t setValue(const ItemUID&, const std::string&);
|
|
|
|
/* access not part of IGraphConfig */
|
|
bool hasItem(const ia_uid iuid) const;
|
|
css_err_t addValue(ia_uid uid, const std::string &val);
|
|
css_err_t addValue(ia_uid uid, int val);
|
|
|
|
// To silence possible compiler warning
|
|
using GraphConfigItem::getValue;
|
|
using GraphConfigItem::setValue;
|
|
};
|
|
|
|
} // namespace GCSS
|
|
#endif /* GCSS_ITEM_H_ */
|