rrclass.h

Go to the documentation of this file.

 
// Copyright (C) 2010-2015 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef RRCLASS_H
#define RRCLASS_H 1
 
#include <stdint.h>
 
#include <string>
#include <ostream>
 
#include <dns/exceptions.h>
 
#include <boost/optional.hpp>
 
// Undefine the macro IN which is defined in some operating systems
// but conflicts the IN RR class.
 
#ifdef IN
#undef IN
#endif
 
namespace isc {
namespace util {
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// forward declarations
class AbstractMessageRenderer;
 
class InvalidRRClass : public DNSTextError {
public:
    InvalidRRClass(const char* file, size_t line, const char* what) :
        DNSTextError(file, line, what) {}
};
 
class IncompleteRRClass : public isc::dns::Exception {
public:
    IncompleteRRClass(const char* file, size_t line, const char* what) :
        isc::dns::Exception(file, line, what) {}
};
 
class RRClass {
public:
 
    explicit RRClass(uint16_t classcode) : classcode_(classcode) {}
    explicit RRClass(const std::string& class_str);
    explicit RRClass(isc::util::InputBuffer& buffer);
 
    static RRClass* createFromText(const std::string& class_str);
 
 
 
 
    const std::string toText() const;
    void toWire(AbstractMessageRenderer& renderer) const;
    void toWire(isc::util::OutputBuffer& buffer) const;
 
 
    uint16_t getCode() const { return (classcode_); }
 
 
    bool equals(const RRClass& other) const
    { return (classcode_ == other.classcode_); }
    bool operator==(const RRClass& other) const { return (equals(other)); }
 
    bool nequals(const RRClass& other) const
    { return (classcode_ != other.classcode_); }
    bool operator!=(const RRClass& other) const { return (nequals(other)); } 
 
    bool operator<(const RRClass& other) const
    { return (classcode_ < other.classcode_); }
 
    // BEGIN_WELL_KNOWN_CLASS_DECLARATIONS
    static const RRClass& HS();
    static const RRClass& NONE();
    static const RRClass& ANY();
    static const RRClass& CH();
    static const RRClass& IN();
    // END_WELL_KNOWN_CLASS_DECLARATIONS
 
private:
    uint16_t classcode_;
};
 
// BEGIN_WELL_KNOWN_CLASS_DEFINITIONS
inline const RRClass&
RRClass::HS() {
    static RRClass rrclass(4);
    return (rrclass);
}
 
inline const RRClass&
RRClass::NONE() {
    static RRClass rrclass(254);
    return (rrclass);
}
 
inline const RRClass&
RRClass::ANY() {
    static RRClass rrclass(255);
    return (rrclass);
}
 
inline const RRClass&
RRClass::CH() {
    static RRClass rrclass(3);
    return (rrclass);
}
 
inline const RRClass&
RRClass::IN() {
    static RRClass rrclass(1);
    return (rrclass);
}
 
// END_WELL_KNOWN_CLASS_DEFINITIONS
 
std::ostream&
operator<<(std::ostream& os, const RRClass& rrclass);
}
}
#endif  // RRCLASS_H
 
// Local Variables: 
// mode: c++
// End: