CMSSW_4_4_3_patch1/src/PhysicsTools/MVAComputer/interface/Variable.h

Go to the documentation of this file.

#ifndef PhysicsTools_MVAComputer_Variable_h
#define PhysicsTools_MVAComputer_Variable_h
// -*- C++ -*-
//
// Package:     MVAComputer
// Class  :     Variable
//

//
// Author:      Christophe Saout <christophe.saout@cern.ch>
// Created:     Sat Apr 24 15:18 CEST 2007
// $Id: Variable.h,v 1.8 2009/03/27 14:33:38 saout Exp $
//

#include <vector>
#include <string>

#include "PhysicsTools/MVAComputer/interface/AtomicId.h"

namespace PhysicsTools {

class Variable {
    public:
        enum Flags {
                FLAG_NONE       = 0,
                FLAG_OPTIONAL   = 1 << 0,
                FLAG_MULTIPLE   = 1 << 1,
                FLAG_ALL        = (1 << 2) - 1
        };

        class Value {
            public:
                inline Value() {}
                inline Value(const Value &orig) :
                        name(orig.name), value(orig.value) {}
                inline Value(AtomicId name, double value) :
                        name(name), value(value) {}

                inline Value &operator = (const Value &orig)
                { name = orig.name; value = orig.value; return *this; }

                inline void setName(AtomicId name) { this->name = name; }
                inline void setValue(double value) { this->value = value; }

                inline AtomicId getName() const { return name; }
                inline double getValue() const { return value; }

            private:
                AtomicId        name;
                double          value;
        };

        class ValueList {
            public:
                typedef std::vector<Value>      _Data;
                typedef _Data::value_type       value_type;
                typedef _Data::pointer          pointer;
                typedef _Data::const_pointer    const_pointer;
                typedef _Data::reference        reference;
                typedef _Data::const_reference  const_reference;
                typedef _Data::iterator         iterator;
                typedef _Data::const_iterator   const_iterator;
                typedef _Data::size_type        size_type;
                typedef _Data::difference_type  difference_type;
                typedef _Data::allocator_type   allocator_type;

                inline ValueList() {}
                inline ValueList(const ValueList &orig) : data_(orig.data_) {}
                inline ValueList(const _Data &orig) : data_(orig) {}
                inline ~ValueList() {}

                inline ValueList &operator = (const ValueList &orig)
                { data_ = orig.data_; return *this; }

                inline void clear()
                { data_.clear(); }

                inline void add(AtomicId id, double value)
                { data_.push_back(Value(id, value)); }

                inline void add(const Value &value)
                { data_.push_back(value); }

                inline size_type size() const { return data_.size(); }
                bool empty() const { return data_.empty(); }

                inline const_iterator begin() const { return data_.begin(); }
                iterator begin() { return data_.begin(); }

                inline const_iterator end() const { return data_.end(); }
                iterator end() { return data_.end(); }

                inline const _Data &values() const { return data_; }
                _Data &values() { return data_; }

                inline const_reference front() const { return *data_.begin(); }
                reference front() { return *data_.begin(); }

                inline const_reference back() const { return *data_.rbegin(); }
                reference back() { return *data_.rbegin(); }

                inline const_pointer data() const { return &front(); }
                pointer data() { return &front(); }

            private:
                std::vector<Value>      data_;
        };

        inline Variable() {}
        inline Variable(const Variable &orig) :
                name(orig.name), flags(orig.flags) {}
        inline Variable(AtomicId name, Flags flags = FLAG_NONE) :
                name(name), flags(flags) {}

        const AtomicId getName() const { return name; }
        Flags getFlags() const { return flags;}

        bool isOptional() const { return flags & FLAG_OPTIONAL; }
        bool isMultiple() const { return flags & FLAG_MULTIPLE; }

    private:
        AtomicId        name;
        Flags           flags;
};

} // namespace PhysicsTools

#endif // PhysicsTools_MVAComputer_Variable_h