main.h

asn格式文件的编译器

	int maxEnumValue;
};


class RealType : public TypeBase
{
  public:
    RealType();
    virtual const char * GetAncestorClass() const;
	virtual std::string GetPrimitiveType() const { return "double";}
    virtual void GenerateOperators(std::ostream & hdr, std::ostream & cxx, const TypeBase & actualType);
	virtual void GenerateConstructors(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
};


class BitStringType : public TypeBase
{
  public:
    BitStringType();
    BitStringType(NamedNumberList&);
    virtual const char * GetAncestorClass() const;
	std::string GetTypeName() const;
	virtual std::string GetPrimitiveType() const { return TypeBase::GetPrimitiveType();}
    virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
  protected:

    NamedNumberList allowedBits;
};


class OctetStringType : public TypeBase
{
  public:
    OctetStringType();
    virtual const char * GetAncestorClass() const;
	std::string GetTypeName() const;
	virtual std::string GetPrimitiveType() const { return "const std::vector<char>&";}
	virtual const char* GetConstrainedType() const;
	virtual void GenerateConstructors(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
    virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
};


class NullType : public TypeBase
{
  public:
    NullType();
    virtual const char * GetAncestorClass() const;
	virtual void BeginParseThisTypeValue() const;
	virtual void EndParseThisTypeValue() const;
};


class SequenceType : public TypeBase
{
    void PrintOn(std::ostream &) const;
  public:
    SequenceType(TypesVector* std,
                 bool extendable,
                 TypesVector * extensions,
                 unsigned tagNum = Tag::UniversalSequence);
    virtual void FlattenUsedTypes();
    virtual TypePtr FlattenThisType(TypePtr& self, const TypeBase & parent);
    virtual bool IsPrimitiveType() const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
    virtual const char * GetAncestorClass() const;
    virtual bool CanReferenceType() const;
    virtual bool ReferencesType(const TypeBase & type) const;

	void GenerateComponent(TypeBase& field, std::ostream & hdr, std::ostream & cxx, std::ostream & inl, int id);
	virtual bool CanBeFwdDeclared(bool isComponent ) const ;
	virtual void RemovePERInvisibleConstraint(const ParameterPtr&);
	virtual bool UseType(const TypeBase& type) const ;
	virtual bool NeedGenInfo() const { return true; }
    virtual void GenerateForwardDecls(std::ostream & hdr);
    virtual RemoveReuslt CanRemoveType(const TypeBase&) ;
    virtual bool RemoveThisType(const TypeBase&);
    virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
  protected:
    TypesVector fields;
    size_t numFields;
	mutable std::vector<bool> needFwdDeclare;
    bool extendable;
    mutable bool detectingLoop;
};


class SequenceOfType : public TypeBase
{
  public:
    SequenceOfType(TypePtr base, ConstraintPtr constraint = ConstraintPtr(), unsigned tag = Tag::UniversalSequence);
    ~SequenceOfType();
    void PrintOn(std::ostream &) const;
    virtual void FlattenUsedTypes();
    virtual TypePtr FlattenThisType(TypePtr& self, const TypeBase & parent);
    virtual bool IsPrimitiveType() const;
    virtual void GenerateForwardDecls(std::ostream & hdr);
    virtual const char * GetAncestorClass() const;
    virtual bool CanReferenceType() const;
    virtual bool ReferencesType(const TypeBase & type) const;
	virtual	std::string GetTypeName() const;
	virtual bool FwdDeclareMe(std::ostream & hdr);
	virtual bool IsSequenceOfType() const { return true;}
	virtual void RemovePERInvisibleConstraint(const ParameterPtr&);
	virtual bool UseType(const TypeBase& type) const ;
	virtual void GenerateConstructors(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
	void SetNonTypedef(bool v) { nonTypedef = v;}
    virtual RemoveReuslt CanRemoveType(const TypeBase&) ;
    virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
 protected:
    TypePtr baseType;
	bool nonTypedef;
};


class SetType : public SequenceType
{
  public:
    SetType();
    SetType(SequenceType& seq);
    virtual const char * GetAncestorClass() const;
};


class SetOfType : public SequenceOfType
{
  public:
    SetOfType(TypePtr base, ConstraintPtr constraint = ConstraintPtr());
	virtual	std::string GetTypeName() const;
};


class ChoiceType : public SequenceType
{
  public:
    ChoiceType(TypesVector * std = NULL,
               bool extendable = false,
               TypesVector * extensions = NULL);
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
    virtual void GenerateOperators(std::ostream & hdr, std::ostream & cxx, const TypeBase & actualType);
    virtual bool IsPrimitiveType() const;
    virtual bool IsChoice() const;
    virtual const char * GetAncestorClass() const;
	void GenerateComponent(TypeBase& field, std::ostream & hdr, std::ostream & cxx, std::ostream& inl, int id);
    virtual RemoveReuslt CanRemoveType(const TypeBase&) ;
	virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
  private:
	  std::vector<TypeBase*> sortedFields;
};


class EmbeddedPDVType : public TypeBase
{
  public:
    EmbeddedPDVType();
    virtual const char * GetAncestorClass() const;
};


class ExternalType : public TypeBase
{
  public:
    ExternalType();
    virtual const char * GetAncestorClass() const;
};


class AnyType : public TypeBase
{
  public:
    AnyType(const std::string& ident);
    void PrintOn(std::ostream & strm) const;
    virtual const char * GetAncestorClass() const;
  protected:
    std::string identifier;
};


class StringTypeBase : public TypeBase
{
  public:
    StringTypeBase(int tag);
	virtual std::string GetTypeName() const;
	virtual std::string GetPrimitiveType() const { return "const std::string&";}
	virtual void GenerateConstructors(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
    virtual void GenerateOperators(std::ostream & hdr, std::ostream & cxx, const TypeBase & actualType);
    virtual bool NeedGenInfo() const;
	virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
	virtual const char* GetCanonicalSetString() const { return NULL;};
  protected:
	const char* canonicalSet;
	const char* canonicalSetRep;
	int canonicalSetSize;
};


class BMPStringType : public StringTypeBase
{
  public:
    BMPStringType();
    virtual const char * GetAncestorClass() const;
	virtual std::string GetPrimitiveType() const { return "const std::wstring&";}
    virtual void GenerateOperators(std::ostream & hdr, std::ostream & cxx, const TypeBase & actualType);
	virtual void GenerateConstructors(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
	virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
};


class GeneralStringType : public StringTypeBase
{
  public:
    GeneralStringType();
    virtual const char * GetAncestorClass() const;
};


class GraphicStringType : public StringTypeBase
{
  public:
    GraphicStringType();
    virtual const char * GetAncestorClass() const;
};


class IA5StringType : public StringTypeBase
{
  public:
    IA5StringType();
    virtual const char * GetAncestorClass() const;
};


class ISO646StringType : public StringTypeBase
{
  public:
    ISO646StringType();
    virtual const char * GetAncestorClass() const;
};


class NumericStringType : public StringTypeBase
{
  public:
    NumericStringType();
    virtual const char * GetAncestorClass() const;
};


class PrintableStringType : public StringTypeBase
{
  public:
    PrintableStringType();
    virtual const char * GetAncestorClass() const;
};


class TeletexStringType : public StringTypeBase
{
  public:
    TeletexStringType();
    virtual const char * GetAncestorClass() const;
};


class T61StringType : public StringTypeBase
{
  public:
    T61StringType();
    virtual const char * GetAncestorClass() const;
};


class UniversalStringType : public StringTypeBase
{
  public:
    UniversalStringType();
    virtual const char * GetAncestorClass() const;
};


class VideotexStringType : public StringTypeBase
{
  public:
    VideotexStringType();
    virtual const char * GetAncestorClass() const;
};


class VisibleStringType : public StringTypeBase
{
  public:
    VisibleStringType();
    virtual const char * GetAncestorClass() const;
};


class UnrestrictedCharacterStringType : public StringTypeBase
{
  public:
    UnrestrictedCharacterStringType();
    virtual const char * GetAncestorClass() const;
};


class GeneralizedTimeType : public TypeBase
{
  public:
    GeneralizedTimeType();
    virtual const char * GetAncestorClass() const;
	virtual std::string GetPrimitiveType() const { return "const char*";}
	virtual void GenerateConstructors(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
};


class UTCTimeType : public TypeBase
{
  public:
    UTCTimeType();
    virtual const char * GetAncestorClass() const;
};


class ObjectDescriptorType : public TypeBase
{
  public:
    ObjectDescriptorType();
    virtual const char * GetAncestorClass() const;
};


class ObjectIdentifierType : public TypeBase
{
  public:
    ObjectIdentifierType();
    virtual const char * GetAncestorClass() const;
	virtual void BeginParseThisTypeValue() const;
	virtual void EndParseThisTypeValue() const;
	virtual void GenerateConstructors(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
};



class ObjectClassBase;
typedef boost::shared_ptr<ObjectClassBase> ObjectClassBasePtr;

class ObjectClassFieldType : public TypeBase
{
  public:
    ObjectClassFieldType(ObjectClassBasePtr  objclass, const std::string& field);
	~ObjectClassFieldType();
    virtual const char * GetAncestorClass() const;
    void PrintOn(std::ostream &) const;
    virtual bool CanReferenceType() const;
    virtual bool ReferencesType(const TypeBase & type) const;
	TypeBase* GetFieldType() ;
	const TypeBase* GetFieldType() const ;
    virtual std::string GetTypeName() const;
	void AddTableConstraint(boost::shared_ptr<TableConstraint> constraint);
    void GenerateDecoder(std::ostream&);
	virtual void GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx);
    std::string GetConstrainedTypeName() const;
  protected:
    ObjectClassBasePtr asnObjectClass;
	std::string asnObjectClassField;
	boost::shared_ptr<TableConstraint> tableConstraint;
};


class ImportedType : public TypeBase
{
  public:
	ImportedType(const TypePtr& ref);
    ImportedType(const std::string& name, bool parameterised);
    virtual const char * GetAncestorClass() const;
    virtual void AdjustIdentifier(bool usingNamespace);
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
    virtual bool IsParameterisedImport() const;

	virtual void BeginParseThisTypeValue() const;
	virtual void EndParseThisTypeValue() const;

	void SetModuleName(const std::string& name) ;
	virtual const std::string& GetCModuleName() const { return cModuleName; }
    const std::string& GetModuleName() const { return moduleName; }
    bool IsPrimitiveType() const;
  protected:
    std::string modulePrefix;
    bool    parameterised;
	const TypePtr reference;
    std::string moduleName;
	std::string cModuleName;
private:
	ImportedType& operator = (const ImportedType&);
};


class InformationObject;
typedef boost::shared_ptr<InformationObject> InformationObjectPtr;


class TypeFromObject : public TypeBase
{
  public:
    TypeFromObject(InformationObjectPtr  obj, const std::string& fld);
	~TypeFromObject();
    virtual const char * GetAncestorClass() const;
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl);
  protected:
	InformationObjectPtr refObj;
	std::string field;
};

class RemovedType : public TypeBase