Be Sweet - a set of visual source code browsers

#ifndef CppTagModelPolicies_H
#define CppTagModelPolicies_H

//////// access policy
class AccessPolicy
{
private:
  AccessQualifier mQualifier;

public:
  AccessPolicy(AccessQualifier access = ePublic) : mQualifier(access) {}
  
	AccessQualifier getAccessQualifier() const { return mQualifier; };
	void setAccessQualifier(AccessQualifier q) { mQualifier = q; };

  bool isPublic() const { return getAccessQualifier() == ePublic; }
	bool isProtected() const { return getAccessQualifier() == eProtected; }
	bool isPrivate() const { return getAccessQualifier() == ePrivate; }
};

class NullAccessPolicy {};


//////// implementation policy
class ImplementationPolicy
{
private:
  ImplementationQualifier mQualifier;

public:
  ImplementationPolicy(ImplementationQualifier q = eDefault) { mQualifier = q; }

  void setImplementationQualifier(ImplementationQualifier q) { mQualifier = q; }
	ImplementationQualifier getImplementationQualifier() const { return mQualifier; }

	bool isVirtual() const { return getImplementationQualifier() == eVirtual; }
  bool isAbstract() const { return getImplementationQualifier() == eAbstract; }
};

class NullImplementationPolicy {};


// const-static policy
class ConstStaticPolicy
{
private:
	bool mIsStatic;
	bool mIsConst;

public:
  ConstStaticPolicy(bool isConst = false, bool isStatic = false) 
  : mIsStatic(isStatic), mIsConst(isConst){}

  void isStatic(bool isStatic) { mIsStatic = isStatic; }
	bool isStatic() const { return mIsStatic; }

  void isConst(bool isConst) { mIsConst = isConst; }
	bool isConst() const { return mIsConst; }
};

class NullConstStaticPolicy{};

//////// global policies
class VariablePolicy
{
private:
  std::string mType;

public:
  VariablePolicy(const std::string &type)
	: mType(type)
  {
    size_t pos;
    if((pos = mType.find("static ")) != std::string::npos) {
      mType.erase(pos, 7);
    }
    if((pos = mType.find("const ")) != std::string::npos) {
      mType.erase(pos, 6);
    }

    rm_dup_space(mType);
  }

  void acceptVisitor(CppTagVisitor *visitor, Variable *variable)
  { visitor->visitVariable(variable); }
};

class FunctionPolicy
{
private:
	std::string mReturnType;
	std::list<Field> mParameters;

public:
	FunctionPolicy(const std::string& returnType);
	FunctionPolicy(const std::string& returnType, const std::list<Field> &parameters);

  void acceptVisitor(CppTagVisitor *visitor, Function *function)
  { visitor->visitFunction(function); }
  
  const std::string& getReturnType() const;
	const std::list<Field>& getParameters() const;

};

///////// member policies
class MethodPolicy : public FunctionPolicy
{
private:

public:
	MethodPolicy(const std::string& returnType)
  : FunctionPolicy(returnType) {}

	MethodPolicy(const std::string& returnType, const std::list<Field> &parameters)
  : FunctionPolicy(returnType, parameters) {}

  virtual void acceptVisitor(CppTagVisitor *visitor, Method *method)
  { visitor->visitMethod(method); }
};

class FieldPolicy : public VariablePolicy
{

public:
  FieldPolicy(const std::string &type)
  : VariablePolicy(type) {}

  void acceptVisitor(CppTagVisitor *visitor, Field *field)
  { visitor->visitField(field); }
};

///////// visitor policies
struct ClassVisitorPolicy
{
  template<class T>
  void static acceptVisitor(CppTagVisitor *v, T *t) 
  { v->visitClass(t); }
};

struct StructVisitorPolicy
{
  template<class T>
  void static acceptVisitor(CppTagVisitor *v, T *t) 
  { v->visitStruct(t); }
};

struct UnionVisitorPolicy
{
  template<class T>
  void static acceptVisitor(CppTagVisitor *v, T *t) 
  { v->visitUnion(t); }
};

#endif