ObjectInstance.h

Go to the documentation of this file.

/* -*- C++ -*-; c-basic-offset: 4; indent-tabs-mode: nil */
/*
 * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */

#ifndef MODB_OBJECTINSTANCE_H_
#define MODB_OBJECTINSTANCE_H_

#include <string>
#include <utility>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/cstdint.hpp>
#include <boost/variant.hpp>

#include "opflex/modb/PropertyInfo.h"
#include "opflex/modb/URI.h"
#include "opflex/modb/MAC.h"
#include "opflex/ofcore/OFTypes.h"

namespace opflex {
namespace modb {

typedef boost::tuple<PropertyInfo::property_type_t,
                     PropertyInfo::cardinality_t,
                     prop_id_t> prop_key_t;

typedef std::pair<class_id_t, URI> reference_t;

size_t hash_value(prop_key_t const& key);

size_t hash_value(reference_t const& key);

} /* namespace modb */
} /* namespace opflex */

#if __cplusplus > 199711L

namespace std {
template<> struct hash<opflex::modb::prop_key_t> {
    std::size_t operator()(const opflex::modb::prop_key_t& u) const {
        return opflex::modb::hash_value(u);
    }
};

template<> struct hash<opflex::modb::reference_t> {
    std::size_t operator()(const opflex::modb::reference_t& p) const {
        return opflex::modb::hash_value(p);
    }
};

} /* namespace std */

#endif

namespace opflex {
namespace modb {

namespace mointernal {

class ObjectInstance {
public:
    ObjectInstance(class_id_t class_id_)
        : class_id(class_id_), local(true) { }

    ObjectInstance(class_id_t class_id_, bool local_)
        : class_id(class_id_), local(local_) { }

    class_id_t getClassId() const { return class_id; }

    bool isLocal() const { return local; }

    bool isSet(prop_id_t prop_id,
               PropertyInfo::property_type_t type,
               PropertyInfo::cardinality_t cardinality = PropertyInfo::SCALAR) const;

    bool unset(prop_id_t prop_id,
               PropertyInfo::property_type_t type,
               PropertyInfo::cardinality_t cardinality);

    uint64_t getUInt64(prop_id_t prop_id) const;

    uint64_t getUInt64(prop_id_t prop_id, size_t index) const;

    size_t getUInt64Size(prop_id_t prop_id) const;

    int64_t getInt64(prop_id_t prop_id) const;

    int64_t getInt64(prop_id_t prop_id, size_t index) const;

    size_t getInt64Size(prop_id_t prop_id) const;

    const std::string& getString(prop_id_t prop_id) const;

    const std::string& getString(prop_id_t prop_id, size_t index) const;

    size_t getStringSize(prop_id_t prop_id) const;

    reference_t getReference(prop_id_t prop_id) const;

    reference_t getReference(prop_id_t prop_id, size_t index) const;

    size_t getReferenceSize(prop_id_t prop_id) const;

    const MAC& getMAC(prop_id_t prop_id) const;

    const MAC& getMAC(prop_id_t prop_id, size_t index) const;

    size_t getMACSize(prop_id_t prop_id) const;

    void setUInt64(prop_id_t prop_id, uint64_t value);

    void setUInt64(prop_id_t prop_id, const std::vector<uint64_t>& value);

    void setString(prop_id_t prop_id, const std::string& value);

    void setString(prop_id_t prop_id, const std::vector<std::string>& value);

    void setInt64(prop_id_t prop_id, int64_t value);

    void setInt64(prop_id_t prop_id, const std::vector<int64_t>& value);

    void setReference(prop_id_t prop_id,
                      class_id_t class_id, const URI& uri);

    void setReference(prop_id_t prop_id,
                      const std::vector<reference_t>& value);

    void setMAC(prop_id_t prop_id, const MAC& value);

    void setMAC(prop_id_t prop_id, const std::vector<MAC>& value);

    void addUInt64(prop_id_t prop_id, uint64_t value);

    void addInt64(prop_id_t prop_id, int64_t value);

    void addString(prop_id_t prop_id, const std::string& value);

    void addReference(prop_id_t prop_id,
                      class_id_t class_id, const URI& uri);

    void addMAC(prop_id_t prop_id, const MAC& value);

private:
    class_id_t class_id;

    struct Value {
        PropertyInfo::property_type_t type;
        PropertyInfo::cardinality_t cardinality;
        boost::variant<boost::blank,
                       uint64_t,
                       int64_t,
                       std::string,
                       reference_t,
                       MAC,
                       std::vector<uint64_t>*,
                       std::vector<int64_t>*,
                       std::vector<std::string>*,
                       std::vector<reference_t>*,
                       std::vector<MAC>*> value;

        Value() {}
        Value(const Value& val);
        ~Value();
        Value& operator=(const Value& val);
    private:
        void clear();
    };

    typedef OF_UNORDERED_MAP<prop_key_t, Value> prop_map_t;
    prop_map_t prop_map;
    bool local;

    friend bool operator==(const ObjectInstance& lhs,
                           const ObjectInstance& rhs);
    friend bool operator!=(const ObjectInstance& lhs,
                           const ObjectInstance& rhs);
    friend bool operator==(const Value& lhs,
                           const Value& rhs);
    friend bool operator!=(const Value& lhs,
                           const Value& rhs);
    template <typename T>
    friend bool equal(const Value& lhs, const Value& rhs);
};

bool operator==(const ObjectInstance& lhs, const ObjectInstance& rhs);
bool operator!=(const ObjectInstance& lhs, const ObjectInstance& rhs);

} /* namespace mointernal */
} /* namespace modb */
} /* namespace opflex */

#endif /* MODB_OBJECTINSTANCE_H_ */