class subst_spec

class map_lines;
class map_transformer
{
public:
    virtual ~map_transformer() = 0;
    virtual void apply_transform(map_lines &map) = 0;
    virtual map_transformer *clone() const = 0;
};
class subst_spec : public map_transformer

    
    void apply_transform(map_lines &map);
    map_transformer *clone() const;

};
struct shuffle_spec : public map_transformer
{
    std::string shuffle;
    shuffle_spec(const std::string &spec)
        : shuffle(spec)
    {
    }
    
    void apply_transform(map_lines &map);
    map_transformer *clone() const;

    map_lines(const map_lines &);
    ~map_lines();
    map_lines &operator = (const map_lines &);

    
    void subst();
    void resolve_shuffles();

    void apply_transforms();

    void init_from(const map_lines &map);
    void release_transforms();
    

    void subst(subst_spec &);

    friend class subst_spec;
    friend class shuffle_spec;
    

    std::vector<subst_spec>  substitutions;
    std::vector<std::string> shuffles;

    std::vector<map_transformer *> transforms;

}
static int find_weight(std::string &s)
{
    return strip_number_tag(s, "weight:");

////////////////////////////////////////////////////////////////////////
// map_transformer

///////////////////////////////////////////////

map_transformer::~map_transformer()
{
}
////////////////////////////////////////////////////////////////////////

//

    : lines(), map_width(0), solid_north(false), solid_east(false),
      solid_south(false), solid_west(false), solid_checked(false)

    : transforms(), lines(), map_width(0), solid_north(false),
      solid_east(false), solid_south(false), solid_west(false),
      solid_checked(false)
{
}
map_lines::map_lines(const map_lines &map)
{
    init_from(map);
}
map_lines &map_lines::operator = (const map_lines &map)
{
    if (this != &map)
        init_from(map);
    return (*this);
}
map_lines::~map_lines()
{
    release_transforms();
}
void map_lines::init_from(const map_lines &map)
{
    release_transforms();
    lines         = map.lines;
    map_width     = map.map_width;
    solid_north   = map.solid_north;
    solid_east    = map.solid_east;
    solid_south   = map.solid_south;
    solid_west    = map.solid_west;
    solid_checked = map.solid_checked;
    for (int i = 0, size = map.transforms.size(); i < size; ++i)
        transforms.push_back( map.transforms[i]->clone() );
}
void map_lines::release_transforms()

    for (int i = 0, size = transforms.size(); i < size; ++i)
        delete transforms[i];
    transforms.clear();

    substitutions.push_back(
        subst_spec( key, sep == ':', repl ) );

    transforms.push_back( new subst_spec( key, sep == ':', repl ) );

        shuffles.push_back(s);

        transforms.push_back( new shuffle_spec(s) );

    substitutions.clear();
    shuffles.clear();

    release_transforms();

void map_lines::subst()

void map_lines::subst(subst_spec &spec)

    for (int i = 0, size = substitutions.size(); i < size; ++i)
    {
        for (int y = 0, ysize = lines.size(); y < ysize; ++y)
            subst(lines[y], substitutions[i]);
    }

    for (int y = 0, ysize = lines.size(); y < ysize; ++y)
        subst(lines[y], spec);

void map_lines::resolve_shuffles()

void map_lines::apply_transforms()

    for (int i = 0, size = shuffles.size(); i < size; ++i)
        resolve_shuffle( shuffles[i] );

    for (int i = 0, size = transforms.size(); i < size; ++i)
        transforms[i]->apply_transform(*this);

    map.resolve_shuffles();
    map.subst();

    map.apply_transforms();

        int weight = strip_number_tag(s, "weight:");

        int weight = find_weight(s);

    int weight = strip_number_tag(s, "weight:");

    int weight = find_weight(s);

}
void subst_spec::apply_transform(map_lines &map)
{
    map.subst(*this);
}
map_transformer *subst_spec::clone() const
{
    return new subst_spec(*this);
}
//////////////////////////////////////////////////////////////////////////
// shuffle_spec
void shuffle_spec::apply_transform(map_lines &map)
{
    map.resolve_shuffle(shuffle);

map_transformer *shuffle_spec::clone() const
{
    return new shuffle_spec(*this);
}

    int weight = strip_number_tag(s, "weight:");

    int weight = find_weight(s);

#  Several SHUFFLE: lines can be used, and the shuffles will be applied in
#  order.

#  Several SHUFFLE: lines can be used, and mixed with SUBST:, and the shuffles
#  and substitutions will be applied in order.

#  Multiple SUBST: lines can be used, and will be applied in order. 
#  Substitutions are performed after any declared shuffles.

#  Multiple SUBST: lines can be used, and mixed with SHUFFLE:, and will be
#  applied in order. 

#  Several SHUFFLE: lines can be used, and the shuffles will be applied in
#  order.

#  Several SHUFFLE: lines can be used, and mixed with SUBST:, and the shuffles
#  and substitutions will be applied in order.

#  Multiple SUBST: lines can be used, and will be applied in order. 
#  Substitutions are performed after any declared shuffles.

#  Multiple SUBST: lines can be used, and mixed with SHUFFLE:, and will be
#  applied in order.