asn1tagdes.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.1 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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 General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _ASN1TAGDES_H_
#define _ASN1TAGDES_H_

// ************************************************************************
// included header files
// + standard includes
#include <iosfwd>
#include <list>
#include <set>
#include <string>

// + libraries

// + local headers
#include "asn1.h"
#include "osberror.h"

// + class declarations
namespace OSB_LIB {
    class Asn1Info;
}

// ************************************************************************
// namespace extensions
namespace OSB_LIB {

// ************************************************************************
// forward declarations

// ************************************************************************
// type definitions

// ************************************************************************
// class definitions
    class Asn1TagDes {
    public:
        typedef std::list<Asn1TagDes> SubTypes;
    public:
        typedef void (*Decoder)(
            const Asn1Byte*    data,
            const size_t       size,
                  std::string& dest
        );

    public:
        explicit Asn1TagDes(const Asn1Tag& tag = Asn1Tag());

    public:
        Asn1Tag tag_;
        std::string des_;

    public:
        void buildFrom(
            Asn1Info& asn1
        );
        const SubTypes& subTypes() const;
        void print(
                  std::ostream& os,
            const std::string&  indent = ""
        ) const;

    public:                             // primitive types
        const std::string decoderName() const;

        void setDecoderName(
            const std::string& decoderName
        );

        bool setDecoders(std::set<std::string>& errors);

        Decoder decoder() const;

    public:                             // constructed types
        void add(const Asn1TagDes& subDes);
        void add(const SubTypes& subTypes);
        void moveOut(
            SubTypes& dest,
            int       level
        );

        static Asn1TagDes* find(
                  SubTypes& src,
            const Asn1Tag&  tag
        );
    private:                            // primitive types
        std::string decoderName_;
        mutable Decoder decoder_;
    private:                            // constructed types
        SubTypes subTypes_;
    };                                  // class Asn1TagDes

    class Asn1InputInfo {
    public:
        typedef std::list<Asn1TagDes> Asn1DesList;
        typedef std::list<Asn1Tag>::const_iterator TagIter;

    public:
        Asn1InputInfo();
    public:
        void clearDes();

        bool read(
            const std::string& path,
                  OsbErrors&   errors
        );

        bool setDecoders(
            OsbErrors& errors
        );

        void write(
            const std::string& path,
                  int          flatten = -1
        ) const;

        void add(const Asn1TagDes& asn1Des);

        const Asn1TagDes* find(
            TagIter begin,
            TagIter end
        ) const;

        const Asn1DesList& asn1Des() const;

        void print(
            std::ostream& os,
            int           flatten = -1
        ) const;

    private:
        static Asn1TagDes* find(
                  Asn1DesList& src,
            const Asn1Tag&     tag
        );

        static const Asn1TagDes* find(
            const Asn1DesList& src,
            const Asn1Tag&     tag
        );

        static const Asn1TagDes* find(
            const Asn1DesList& src,
                  TagIter      begin,
                  TagIter      end
        );

    public:
        size_t blkSize_;
        Asn1Byte blkFiller_;
    private:
        Asn1DesList asn1Des_;
    };                                  // class Asn1InputInfo

    class Asn1DesParser {
    public:
        // defined below
        class Error;
    public:
        explicit Asn1DesParser(
            std::istream& is,
            size_t        lineNo = 1
        );

    public:
        bool getDes(Asn1TagDes& dest);
        size_t lineNo() const;
        size_t colNo() const;
    private:
        Asn1DesParser(const Asn1DesParser& rhs);
        Asn1DesParser operator=(const Asn1DesParser& rhs);
    private:
        bool getDes(
            Asn1TagDes& dest,
            bool        readTag
        );
        bool getChar(char& c);
        bool nextToken();
        void getComposed(Asn1TagDes& parent);
        void getPrimitive(Asn1TagDes& dest);
        Error error(OsbBaseError::ErrorNo errNo);

    private:
        std::istream& is_;
        size_t lineNo_;
        size_t colNo_;
        std::string curToken_;
        char separator_;
    };                                  // class Asn1DesParser

    class Asn1DesParser::Error : public OsbException {
    public:
        Error(
            ErrorNo      errNo,
            size_t       line,
            size_t       col
        );
    public:
        size_t line() const;
        size_t col() const;
    private:
        size_t line_;
        size_t col_;
    };                                  // class Asn1DesParser::Error
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _ASN1TAGDES_H_

---